Embedded SDK
Embedded SDK
Loading...
Searching...
No Matches
nbgl_obj.c
Go to the documentation of this file.
1
6/*********************
7 * INCLUDES
8 *********************/
9#include <string.h>
10
11#include "app_config.h"
12#include "nbgl_obj.h"
13#include "nbgl_draw.h"
14#include "nbgl_front.h"
15#include "nbgl_debug.h"
16#include "nbgl_screen.h"
17#include "nbgl_touch.h"
18#include "os_print.h"
19#include "os_helpers.h"
20#include "os_pic.h"
21#include "glyphs.h"
22#ifdef HAVE_SERIALIZED_NBGL
23#include "nbgl_serialize.h"
24#include "os_io_seproxyhal.h"
25#endif
26#ifdef BUILD_SCREENSHOTS
27#include "json_scenario.h"
28#endif // BUILD_SCREENSHOTS
29
30/*********************
31 * DEFINES
32 *********************/
33// max number of letters in TEXT_ENTRY
34#define NB_MAX_LETTERS 9
35
36#if defined(TARGET_STAX)
37#define INTER_DASHES 10
38#elif defined(TARGET_FLEX)
39#define INTER_DASHES 8
40#endif // TARGETS
41
42/**********************
43 * TYPEDEFS
44 **********************/
45typedef void (*draw_function_t)(nbgl_obj_t *obj, nbgl_obj_t *prevObj, bool computePosition);
46
47/**********************
48 * STATIC PROTOTYPES
49 **********************/
50static void draw_screen(nbgl_container_t *obj, nbgl_obj_t *prevObj, bool computePosition);
51static void draw_container(nbgl_container_t *obj, nbgl_obj_t *prevObj, bool computePosition);
52static void draw_image(nbgl_image_t *obj, nbgl_obj_t *prevObj, bool computePosition);
53static void draw_button(nbgl_button_t *obj, nbgl_obj_t *prevObj, bool computePosition);
54#ifdef HAVE_SE_TOUCH
55static void draw_line(nbgl_line_t *obj, nbgl_obj_t *prevObj, bool computePosition);
56static void draw_switch(nbgl_switch_t *obj, nbgl_obj_t *prevObj, bool computePosition);
57static void draw_radioButton(nbgl_radio_t *obj, nbgl_obj_t *prevObj, bool computePosition);
58static void draw_pageIndicator(nbgl_page_indicator_t *obj,
59 nbgl_obj_t *prevObj,
60 bool computePosition);
61static void draw_spinner(nbgl_spinner_t *obj, nbgl_obj_t *prevObj, bool computePosition);
62#else // HAVE_SE_TOUCH
63static void draw_textEntry(nbgl_text_entry_t *obj, nbgl_obj_t *prevObj, bool computePosition);
64#endif // HAVE_SE_TOUCH
65static void draw_progressBar(nbgl_progress_bar_t *obj, nbgl_obj_t *prevObj, bool computePosition);
66static void draw_textArea(nbgl_text_area_t *obj, nbgl_obj_t *prevObj, bool computePosition);
67#ifdef NBGL_QRCODE
68static void draw_qrCode(nbgl_qrcode_t *obj, nbgl_obj_t *prevObj, bool computePosition);
69#endif // NBGL_QRCODE
70#ifdef NBGL_KEYBOARD
71static void draw_keyboard(nbgl_keyboard_t *obj, nbgl_obj_t *prevObj, bool computePosition);
72#endif // NBGL_KEYBOARD
73#ifdef NBGL_KEYPAD
74static void draw_keypad(nbgl_keypad_t *obj, nbgl_obj_t *prevObj, bool computePosition);
75#endif // NBGL_KEYPAD
76static void draw_image_file(nbgl_image_file_t *obj, nbgl_obj_t *prevObj, bool computePosition);
77#ifdef NBGL_MASKING
78static void draw_mask_control(nbgl_mask_control_t *obj, nbgl_obj_t *prevObj, bool computePosition);
79#endif // NBGL_MASKING
80
81static void extendRefreshArea(nbgl_area_t *obj);
82
83/**********************
84 * STATIC VARIABLES
85 **********************/
86// area to resfresh
87static nbgl_area_t refreshArea;
88
89// boolean used to enable/forbid drawing/refresh by Application
90static bool objDrawingDisabled;
91
92// boolean used to indicate a manual refresh area extension
93static bool objRefreshAreaDone;
94
95// indexed by nbgl_obj_type_t
96static const draw_function_t draw_functions[NB_OBJ_TYPES] = {
97 [SCREEN] = (draw_function_t) draw_screen,
98 [CONTAINER] = (draw_function_t) draw_container,
99 [IMAGE] = (draw_function_t) draw_image,
100 [TEXT_AREA] = (draw_function_t) draw_textArea,
101 [BUTTON] = (draw_function_t) draw_button,
102#ifdef HAVE_SE_TOUCH
103 [LINE] = (draw_function_t) draw_line,
104 [SWITCH] = (draw_function_t) draw_switch,
105 [PAGE_INDICATOR] = (draw_function_t) draw_pageIndicator,
106 [RADIO_BUTTON] = (draw_function_t) draw_radioButton,
107#ifdef NBGL_QRCODE
108 [QR_CODE] = (draw_function_t) draw_qrCode,
109#endif // NBGL_QRCODE
110 [SPINNER] = (draw_function_t) draw_spinner,
111#endif // HAVE_SE_TOUCH
112 [PROGRESS_BAR] = (draw_function_t) draw_progressBar,
113#ifdef NBGL_KEYBOARD
114 [KEYBOARD] = (draw_function_t) draw_keyboard,
115#endif // NBGL_KEYBOARD
116#ifdef NBGL_KEYPAD
117 [KEYPAD] = (draw_function_t) draw_keypad,
118#endif // NBGL_KEYPAD
119 [IMAGE_FILE] = (draw_function_t) draw_image_file,
120#ifndef HAVE_SE_TOUCH
121 [TEXT_ENTRY] = (draw_function_t) draw_textEntry,
122#endif // HAVE_SE_TOUCH
123#ifdef NBGL_MASKING
124 [MASK_CONTROL] = (draw_function_t) draw_mask_control,
125#endif // NBGL_MASKING
126};
127/**********************
128 * VARIABLES
129 **********************/
130// buffer used either for image file uncompression and side screen string drawing
131uint8_t ramBuffer[GZLIB_UNCOMPRESSED_CHUNK];
132
133#ifdef BUILD_SCREENSHOTS
134// Variables used to store important values (nb lines, bold state etc)
135extern uint16_t last_nb_lines, last_nb_pages;
136extern bool last_bold_state, verbose;
137#endif // BUILD_SCREENSHOTS
138
139/**********************
140 * STATIC PROTOTYPES
141 **********************/
142extern const char *get_ux_loc_string(uint32_t index);
143
144/**********************
145 * GLOBAL FUNCTIONS
146 **********************/
147
148static void compute_relativePosition(nbgl_obj_t *obj, nbgl_obj_t *prevObj)
149{
150 nbgl_container_t *parent = (nbgl_container_t *) (obj->parent);
151 // LOG_DEBUG(OBJ_LOGGER,"compute_relativePosition()\n");
152 // compute object absolute position thanks to layout/alignment
153 if (obj->alignment == NO_ALIGNMENT) {
154 LOG_DEBUG(
155 OBJ_LOGGER,
156 "compute_relativePosition() without align to, parent->layout = %d, prevObj = %p\n",
157 parent->layout,
158 prevObj);
159 // align to parent, depending of layout
160 if (parent->layout == VERTICAL) {
161 obj->rel_x0 = obj->alignmentMarginX;
162 if (prevObj != NULL) {
163 obj->rel_y0 = prevObj->rel_y0 + prevObj->area.height + obj->alignmentMarginY;
164 }
165 else {
166 obj->rel_y0 = obj->alignmentMarginY;
167 }
168 }
169 else { // HORIZONTAL
170 if (prevObj != NULL) {
171 obj->rel_x0 = prevObj->rel_x0 + prevObj->area.width + obj->alignmentMarginX;
172 }
173 else {
174 obj->rel_x0 = obj->alignmentMarginX;
175 }
176 obj->rel_y0 = obj->alignmentMarginY;
177 }
178 }
179 else {
180 nbgl_obj_t *alignToObj = obj->alignTo;
181 if (alignToObj == NULL) {
182 alignToObj = obj->parent;
183 LOG_DEBUG(OBJ_LOGGER, "compute_relativePosition() with align to parent\n");
184 }
185 else {
186 LOG_DEBUG(OBJ_LOGGER, "compute_relativePosition() with align to = %p\n", alignToObj);
187 }
188 // align to the given object, with the given constraints
189 if (alignToObj == obj->parent) {
190 // align inside if the reference is the parent
191 switch (obj->alignment) {
192 case TOP_LEFT:
193 obj->rel_x0 = obj->alignmentMarginX;
194 obj->rel_y0 = obj->alignmentMarginY;
195 break;
196 case TOP_MIDDLE:
197 obj->rel_x0
198 = (parent->obj.area.width - obj->area.width) / 2 + obj->alignmentMarginX;
199 obj->rel_y0 = obj->alignmentMarginY;
200 break;
201 case TOP_RIGHT:
202 obj->rel_x0
203 = (parent->obj.area.width - obj->area.width) - obj->alignmentMarginX;
204 obj->rel_y0 = obj->alignmentMarginY;
205 break;
206 case MID_LEFT:
207 obj->rel_x0 = obj->alignmentMarginX;
208 obj->rel_y0
209 = (parent->obj.area.height - obj->area.height) / 2 + obj->alignmentMarginY;
210 break;
211 case CENTER:
212 obj->rel_x0
213 = (parent->obj.area.width - obj->area.width) / 2 + obj->alignmentMarginX;
214 obj->rel_y0
215 = (parent->obj.area.height - obj->area.height) / 2 + obj->alignmentMarginY;
216 break;
217 case MID_RIGHT:
218 obj->rel_x0
219 = (parent->obj.area.width - obj->area.width) - obj->alignmentMarginX;
220 obj->rel_y0
221 = (parent->obj.area.height - obj->area.height) / 2 + obj->alignmentMarginY;
222 break;
223 case BOTTOM_LEFT:
224 obj->rel_x0 = obj->alignmentMarginX;
225 obj->rel_y0
226 = (parent->obj.area.height - obj->area.height) - obj->alignmentMarginY;
227 break;
228 case BOTTOM_MIDDLE:
229 obj->rel_x0
230 = (parent->obj.area.width - obj->area.width) / 2 + obj->alignmentMarginX;
231 obj->rel_y0
232 = (parent->obj.area.height - obj->area.height) - obj->alignmentMarginY;
233 break;
234 case BOTTOM_RIGHT:
235 obj->rel_x0
236 = (parent->obj.area.width - obj->area.width) - obj->alignmentMarginX;
237 obj->rel_y0
238 = (parent->obj.area.height - obj->area.height) - obj->alignmentMarginY;
239 break;
240 default:
241 // not supported
242 break;
243 }
244 }
245 else {
246 // align outside if the reference is a "brother"
247 switch (obj->alignment) {
248 case TOP_LEFT:
249 obj->rel_x0 = alignToObj->rel_x0 + obj->alignmentMarginX;
250 obj->rel_y0 = alignToObj->rel_y0 - obj->area.height - obj->alignmentMarginY;
251 break;
252 case TOP_MIDDLE:
253 obj->rel_x0 = alignToObj->rel_x0
254 + (alignToObj->area.width - obj->area.width) / 2
255 + obj->alignmentMarginX;
256 obj->rel_y0 = alignToObj->rel_y0 - obj->area.height - obj->alignmentMarginY;
257 break;
258 case TOP_RIGHT:
259 obj->rel_x0 = alignToObj->rel_x0 + (alignToObj->area.width - obj->area.width)
260 - obj->alignmentMarginX;
261 obj->rel_y0 = alignToObj->rel_y0 - obj->area.height - obj->alignmentMarginY;
262 break;
263
264 case LEFT_TOP:
265 obj->rel_x0 = alignToObj->rel_x0 - obj->area.width - obj->alignmentMarginX;
266 obj->rel_y0 = alignToObj->rel_y0 + obj->alignmentMarginY;
267 break;
268 case MID_LEFT:
269 obj->rel_x0 = alignToObj->rel_x0 - obj->area.width - obj->alignmentMarginX;
270 obj->rel_y0 = alignToObj->rel_y0
271 + (alignToObj->area.height - obj->area.height) / 2
272 + obj->alignmentMarginY;
273 break;
274 case LEFT_BOTTOM:
275 obj->rel_x0 = alignToObj->rel_x0 - obj->area.width - obj->alignmentMarginX;
276 obj->rel_y0 = alignToObj->rel_y0 + (alignToObj->area.height - obj->area.height)
277 + obj->alignmentMarginY;
278 break;
279
280 case RIGHT_TOP:
281 obj->rel_x0
282 = alignToObj->rel_x0 + alignToObj->area.width + obj->alignmentMarginX;
283 obj->rel_y0 = alignToObj->rel_y0 + obj->alignmentMarginY;
284 break;
285 case MID_RIGHT:
286 obj->rel_x0
287 = alignToObj->rel_x0 + alignToObj->area.width + obj->alignmentMarginX;
288 obj->rel_y0 = alignToObj->rel_y0
289 + (alignToObj->area.height - obj->area.height) / 2
290 + obj->alignmentMarginY;
291 break;
292 case RIGHT_BOTTOM:
293 obj->rel_x0
294 = alignToObj->rel_x0 + alignToObj->area.width + obj->alignmentMarginX;
295 obj->rel_y0 = alignToObj->rel_y0 + (alignToObj->area.height - obj->area.height)
296 + obj->alignmentMarginY;
297 break;
298
299 case BOTTOM_LEFT:
300 obj->rel_x0 = alignToObj->rel_x0 + obj->alignmentMarginX;
301 obj->rel_y0
302 = alignToObj->rel_y0 + alignToObj->area.height + obj->alignmentMarginY;
303 break;
304 case BOTTOM_MIDDLE:
305 obj->rel_x0 = alignToObj->rel_x0
306 + (alignToObj->area.width - obj->area.width) / 2
307 + obj->alignmentMarginX;
308 obj->rel_y0
309 = alignToObj->rel_y0 + alignToObj->area.height + obj->alignmentMarginY;
310 break;
311 case BOTTOM_RIGHT:
312 obj->rel_x0 = alignToObj->rel_x0 + (alignToObj->area.width - obj->area.width)
313 - obj->alignmentMarginX;
314 obj->rel_y0
315 = alignToObj->rel_y0 + alignToObj->area.height + obj->alignmentMarginY;
316 break;
317 default:
318 // not supported
319 break;
320 }
321 }
322 }
323}
324
325static void compute_position(nbgl_obj_t *obj, nbgl_obj_t *prevObj)
326{
327 nbgl_container_t *parent = (nbgl_container_t *) (obj->parent);
328
329 compute_relativePosition(obj, prevObj);
330
331 if (parent == NULL) {
332 // HUGE issue
333 return;
334 }
335 // LOG_DEBUG(OBJ_LOGGER,"compute_position(), parent.type = %d, parent->obj.area.x0 = %d,
336 // obj->rel_x0=%d\n",parent->type,parent->obj.area.x0,obj->rel_x0);
337 // LOG_DEBUG(OBJ_LOGGER,"compute_position(), parent->obj.area.y0 = %d,
338 // obj->rel_y0=%d\n",parent->obj.area.y0,obj->rel_y0);
339
340 obj->area.x0 = parent->obj.area.x0 + obj->rel_x0;
341 obj->area.y0 = parent->obj.area.y0 + obj->rel_y0;
342
343 if ((obj->area.x0 + obj->area.width) > SCREEN_WIDTH) {
344 LOG_FATAL(OBJ_LOGGER,
345 "compute_position(), forbidden width, obj->type = %d, x0=%d, width=%d\n",
346 obj->type,
347 obj->area.x0,
348 obj->area.width);
349 }
350#ifdef HAVE_SE_TOUCH
351 if ((obj->area.y0 + obj->area.height) > SCREEN_HEIGHT) {
352 LOG_FATAL(OBJ_LOGGER,
353 "compute_position(), forbidden height, obj->type = %d, y0=%d, height=%d\n",
354 obj->type,
355 obj->area.y0,
356 obj->area.height);
357 }
358#endif // HAVE_SE_TOUCH
359}
360
361static void draw_screen(nbgl_container_t *obj, nbgl_obj_t *prevObj, bool computePosition)
362{
363 nbgl_area_t rectArea;
364
365 UNUSED(prevObj);
366 UNUSED(computePosition);
367
368 rectArea.backgroundColor = obj->obj.area.backgroundColor;
369 rectArea.x0 = obj->obj.area.x0;
370 rectArea.y0 = obj->obj.area.y0;
371 rectArea.width = obj->obj.area.width;
372 rectArea.height = obj->obj.area.height;
373 nbgl_frontDrawRect(&rectArea);
374}
375
376static void draw_container(nbgl_container_t *obj, nbgl_obj_t *prevObj, bool computePosition)
377{
378 if (computePosition) {
379 compute_position((nbgl_obj_t *) obj, prevObj);
380 }
381 LOG_DEBUG(OBJ_LOGGER,
382 "draw_container(), x0 = %d, y0 = %d, width = %d, height = %d\n",
383 obj->obj.area.x0,
384 obj->obj.area.y0,
385 obj->obj.area.width,
386 obj->obj.area.height);
387 // inherit background from parent
388 obj->obj.area.backgroundColor = obj->obj.parent->area.backgroundColor;
389 if (obj->forceClean) {
390 nbgl_frontDrawRect((nbgl_area_t *) obj);
391 }
392}
393
394#ifdef HAVE_SE_TOUCH
403static void draw_button(nbgl_button_t *obj, nbgl_obj_t *prevObj, bool computePosition)
404{
405 uint16_t textWidth = 0;
406 const char *text = NULL;
407#define ICON_TEXT_SPACE 12
408
409 if (computePosition) {
410 compute_position((nbgl_obj_t *) obj, prevObj);
411 }
412 LOG_DEBUG(OBJ_LOGGER,
413 "draw_button(), x0 = %d, y0 = %d, width = %d, height = %d\n",
414 obj->obj.area.x0,
415 obj->obj.area.y0,
416 obj->obj.area.width,
417 obj->obj.area.height);
418
419 // inherit background from parent
420 obj->obj.area.backgroundColor = obj->obj.parent->area.backgroundColor;
421 // draw the rounded corner rectangle if necessary
422 if ((obj->innerColor == obj->borderColor)
423 && (obj->innerColor != obj->obj.area.backgroundColor)) {
424 nbgl_drawRoundedRect((nbgl_area_t *) obj, obj->radius, obj->innerColor);
425 }
426 else {
427 nbgl_drawRoundedBorderedRect(
428 (nbgl_area_t *) obj, obj->radius, 2, obj->innerColor, obj->borderColor);
429 }
430 // get the text of the button from the callback if not NULL
431 if (obj->onDrawCallback != NULL) {
432 obj->text = obj->onDrawCallback(obj->token);
433 }
434 text = obj->text;
435 // draw the text (right of the icon, with 8 pixels between them)
436 if (text != NULL) {
437 nbgl_area_t rectArea;
438 // Compute available with & height to display the text
439 rectArea.x0 = obj->obj.area.x0;
440 rectArea.y0 = obj->obj.area.y0;
441 // Only one line of text
442 rectArea.height = nbgl_getFontHeight(obj->fontId);
443 rectArea.y0 += (obj->obj.area.height - rectArea.height) / 2;
444 rectArea.width = obj->obj.area.width;
445 if (obj->icon != NULL) {
446 rectArea.x0 += obj->icon->width + ICON_TEXT_SPACE;
447 rectArea.width -= obj->icon->width + ICON_TEXT_SPACE;
448 }
449 // Compute the width & number of characters displayed on first line
450 uint16_t textLen;
451 nbgl_getTextMaxLenAndWidth(obj->fontId, text, rectArea.width, &textLen, &textWidth, true);
452
453#ifdef BUILD_SCREENSHOTS
454 store_string_infos(text, obj->fontId, &rectArea, true, 1, 1, false);
455#endif // BUILD_SCREENSHOTS
456
457 // Center the text, horizontally
458 if (textWidth < rectArea.width) {
459 rectArea.x0 += (rectArea.width - textWidth) / 2;
460 }
461 LOG_DEBUG(OBJ_LOGGER, "draw_button(), text = %s\n", text);
462 rectArea.backgroundColor = obj->innerColor;
463 nbgl_drawText(&rectArea, text, textLen, obj->fontId, obj->foregroundColor);
464 }
465 // draw the icon, if any
466 if (obj->icon != NULL) {
467 uint16_t iconX0, iconY0;
468 nbgl_area_t rectArea;
469
470 if (text != NULL) {
471 iconX0 = obj->obj.area.x0
472 + (obj->obj.area.width - (textWidth + obj->icon->width + ICON_TEXT_SPACE)) / 2;
473 }
474 else {
475 iconX0 = obj->obj.area.x0 + (obj->obj.area.width - obj->icon->width) / 2;
476 }
477 LOG_DEBUG(OBJ_LOGGER,
478 "draw_button(), obj->obj.area.height = %d, obj->iconHeight = %d\n",
479 obj->obj.area.height,
480 obj->icon->height);
481 iconY0 = obj->obj.area.y0 + (obj->obj.area.height - obj->icon->height) / 2;
482
483 rectArea.backgroundColor = obj->innerColor;
484 rectArea.x0 = iconX0;
485 rectArea.y0 = iconY0;
486 rectArea.width = obj->icon->width;
487 rectArea.height = obj->icon->height;
488 rectArea.bpp = obj->icon->bpp;
489
490 nbgl_drawIcon(&rectArea, NO_TRANSFORMATION, obj->foregroundColor, obj->icon);
491 }
492}
493
502static void draw_line(nbgl_line_t *obj, nbgl_obj_t *prevObj, bool computePosition)
503{
504 nbgl_area_t rectArea;
505 if (computePosition) {
506 compute_position((nbgl_obj_t *) obj, prevObj);
507 }
508 LOG_DEBUG(OBJ_LOGGER, "draw_line(), x0 = %d, y0 = %d\n", obj->obj.area.x0, obj->obj.area.y0);
509 // inherit background from parent
510 obj->obj.area.backgroundColor = obj->obj.parent->area.backgroundColor;
511 LOG_DEBUG(OBJ_LOGGER,
512 "draw_line(), backgroundColor = %d, lineColor = %d\n",
513 obj->obj.area.backgroundColor,
514 obj->lineColor);
515 rectArea.x0 = obj->obj.area.x0;
516 rectArea.y0 = obj->obj.area.y0;
517 if (obj->direction == VERTICAL) {
518 rectArea.width = obj->obj.area.width = obj->thickness;
519 rectArea.backgroundColor = obj->lineColor;
520 rectArea.height = obj->obj.area.height;
521 nbgl_frontDrawRect(&rectArea);
522 }
523 else {
524 uint8_t mask;
525 if (obj->thickness == 1) {
526 mask = 0x1 << (obj->offset & 0x3);
527 }
528 else if (obj->thickness == 2) {
529 mask = 0x3 << ((obj->offset < 3) ? obj->offset : 2);
530 }
531 else if (obj->thickness == 3) {
532 mask = 0x7 << (obj->offset & 0x1);
533 }
534 else if (obj->thickness == 4) {
535 mask = 0xF;
536 }
537 else {
538 LOG_WARN(OBJ_LOGGER, "draw_line(), forbidden thickness = %d\n", obj->thickness);
539 return;
540 }
541 rectArea.width = obj->obj.area.width;
542 rectArea.height = obj->obj.area.height = VERTICAL_ALIGNMENT;
543 rectArea.backgroundColor = obj->obj.area.backgroundColor;
544 nbgl_frontDrawHorizontalLine(&rectArea, mask, obj->lineColor);
545 }
546}
547#else // HAVE_SE_TOUCH
556static void draw_button(nbgl_button_t *obj, nbgl_obj_t *prevObj, bool computePosition)
557{
558 uint16_t textWidth = 0;
559 const char *text = NULL;
560#define ICON_TEXT_SPACE 2
561
562 if (computePosition) {
563 compute_position((nbgl_obj_t *) obj, prevObj);
564 }
565 LOG_DEBUG(OBJ_LOGGER,
566 "draw_button(), x0 = %d, y0 = %d, width = %d, height = %d\n",
567 obj->obj.area.x0,
568 obj->obj.area.y0,
569 obj->obj.area.width,
570 obj->obj.area.height);
571
572 // inherit background from parent
573 obj->obj.area.backgroundColor = obj->obj.parent->area.backgroundColor;
574 // draw the rounded corner rectangle if necessary
575 nbgl_drawRoundedRect((nbgl_area_t *) obj, obj->radius, obj->innerColor);
576
577 // get the text of the button from the callback if not NULL
578 if (obj->onDrawCallback != NULL) {
579 obj->text = obj->onDrawCallback(obj->token);
580 }
581 text = obj->text;
582 // draw the text (right of the icon, with ICON_TEXT_SPACE pixels between them)
583 if (text != NULL) {
584 nbgl_area_t rectArea;
585 // Compute available with & height to display the text
586 rectArea.x0 = obj->obj.area.x0;
587 rectArea.y0 = obj->obj.area.y0;
588 // Only one line of text is allowed
589 rectArea.height = nbgl_getFontHeight(obj->fontId);
590 rectArea.y0 += (obj->obj.area.height - rectArea.height) / 2;
591 rectArea.width = obj->obj.area.width;
592 if (obj->icon != NULL) {
593 rectArea.x0 += obj->icon->width + ICON_TEXT_SPACE;
594 rectArea.width -= obj->icon->width + ICON_TEXT_SPACE;
595 }
596 // Compute the width & number of characters displayed on first line
597 uint16_t textLen;
598 nbgl_getTextMaxLenAndWidth(obj->fontId, text, rectArea.width, &textLen, &textWidth, true);
599
600 // Center the text, horizontally
601 if (textWidth < rectArea.width) {
602 rectArea.x0 += (rectArea.width - textWidth) / 2;
603 }
604 LOG_DEBUG(OBJ_LOGGER, "draw_button(), text = %s\n", text);
605 rectArea.backgroundColor = obj->innerColor;
606 nbgl_drawText(&rectArea, text, textLen, obj->fontId, obj->foregroundColor);
607 }
608 // draw the icon, if any
609 if (obj->icon != NULL) {
610 uint16_t iconX0, iconY0;
611 nbgl_area_t rectArea;
612
613 if (text != NULL) {
614 iconX0 = obj->obj.area.x0
615 + (obj->obj.area.width - (textWidth + obj->icon->width + ICON_TEXT_SPACE)) / 2;
616 }
617 else {
618 iconX0 = obj->obj.area.x0 + (obj->obj.area.width - obj->icon->width) / 2;
619 }
620 LOG_DEBUG(OBJ_LOGGER,
621 "draw_button(), obj->obj.area.height = %d, obj->iconHeight = %d\n",
622 obj->obj.area.height,
623 obj->icon->height);
624 iconY0 = obj->obj.area.y0 + (obj->obj.area.height - obj->icon->height) / 2;
625
626 rectArea.backgroundColor = obj->innerColor;
627 rectArea.x0 = iconX0;
628 rectArea.y0 = iconY0;
629 rectArea.width = obj->icon->width;
630 rectArea.height = obj->icon->height;
631 rectArea.bpp = obj->icon->bpp;
632
633 nbgl_drawIcon(&rectArea, NO_TRANSFORMATION, obj->foregroundColor, obj->icon);
634 }
635}
636#endif // HAVE_SE_TOUCH
637
638static void draw_image(nbgl_image_t *obj, nbgl_obj_t *prevObj, bool computePosition)
639{
640 const nbgl_icon_details_t *iconDetails;
641 nbgl_color_map_t colorMap;
642
643 // if buffer is NULL, let's try to call onDrawCallback, if not NULL, to get it
644 if (obj->buffer == NULL) {
645 if (obj->onDrawCallback != NULL) {
646 iconDetails = obj->onDrawCallback(obj->token);
647 }
648 else {
649 return;
650 }
651 }
652 else {
653 iconDetails = obj->buffer;
654 }
655 if (iconDetails == NULL) {
656 return;
657 }
658
659 // use dimension and bpp from the icon details
660 obj->obj.area.width = iconDetails->width;
661 obj->obj.area.height = iconDetails->height;
662 obj->obj.area.bpp = iconDetails->bpp;
663 if (computePosition) {
664 compute_position((nbgl_obj_t *) obj, prevObj);
665 }
666 LOG_DEBUG(OBJ_LOGGER, "draw_image(), x0 = %d, y0 = %d\n", obj->obj.area.x0, obj->obj.area.y0);
667 // inherit background from parent
668 obj->obj.area.backgroundColor = obj->obj.parent->area.backgroundColor;
669 if (obj->obj.area.bpp == NBGL_BPP_1) {
670 colorMap = obj->foregroundColor;
671 }
672 else if (obj->obj.area.bpp == NBGL_BPP_2) {
673 colorMap = ((WHITE << 6) | (LIGHT_GRAY << 4) | (DARK_GRAY << 2) | BLACK);
674 }
675 else {
676 colorMap = obj->foregroundColor;
677 }
678
679 nbgl_drawIcon((nbgl_area_t *) obj, obj->transformation, colorMap, iconDetails);
680}
681
682#ifdef HAVE_SE_TOUCH
683static void draw_switch(nbgl_switch_t *obj, nbgl_obj_t *prevObj, bool computePosition)
684{
685 nbgl_area_t rectArea;
686
687 // force dimensions
688 obj->obj.area.width = C_switch_60_40.width;
689 obj->obj.area.height = C_switch_60_40.height;
690 if (computePosition) {
691 compute_position((nbgl_obj_t *) obj, prevObj);
692 }
693 LOG_DEBUG(OBJ_LOGGER, "draw_switch(), x0 = %d, y0 = %d\n", obj->obj.area.x0, obj->obj.area.y0);
694
695 // inherit background from parent
696 obj->obj.area.backgroundColor = obj->obj.parent->area.backgroundColor;
697
698 rectArea.x0 = obj->obj.area.x0;
699 rectArea.y0 = obj->obj.area.y0;
700 rectArea.width = obj->obj.area.width;
701 rectArea.height = obj->obj.area.height;
702 rectArea.backgroundColor = obj->obj.area.backgroundColor;
703 rectArea.bpp = NBGL_BPP_1;
704 if (obj->state == OFF_STATE) {
705 nbgl_frontDrawImage(&rectArea, C_switch_60_40.bitmap, NO_TRANSFORMATION, obj->offColor);
706 }
707 else {
708 nbgl_frontDrawImage(&rectArea, C_switch_60_40.bitmap, VERTICAL_MIRROR, obj->onColor);
709 }
710}
711
712static void draw_radioButton(nbgl_radio_t *obj, nbgl_obj_t *prevObj, bool computePosition)
713{
714 nbgl_area_t rectArea;
715 const nbgl_icon_details_t *icon;
716 nbgl_color_map_t color_map;
717
718 // force dimensions
719 obj->obj.area.width = RADIO_WIDTH;
720 obj->obj.area.height = RADIO_HEIGHT;
721 if (computePosition) {
722 compute_position((nbgl_obj_t *) obj, prevObj);
723 }
724 LOG_DEBUG(OBJ_LOGGER,
725 "draw_radioButton(), x0 = %d, y0 = %d, state = %d\n",
726 obj->obj.area.x0,
727 obj->obj.area.y0,
728 obj->state);
729
730 // inherit background from parent
731 obj->obj.area.backgroundColor = obj->obj.parent->area.backgroundColor;
732
733 if (obj->state == OFF_STATE) {
734 icon = &RADIO_OFF_ICON;
735 color_map = obj->borderColor;
736 }
737 else {
738 icon = &RADIO_ON_ICON;
739 color_map = obj->activeColor;
740 }
741 rectArea.x0 = obj->obj.area.x0;
742 rectArea.y0 = obj->obj.area.y0;
743 rectArea.width = obj->obj.area.width;
744 rectArea.height = obj->obj.area.height;
745 rectArea.backgroundColor = obj->obj.area.backgroundColor;
746 rectArea.bpp = icon->bpp;
747 nbgl_drawIcon(&rectArea, NO_TRANSFORMATION, color_map, icon);
748}
749#endif // HAVE_SE_TOUCH
750
758static void draw_progressBar(nbgl_progress_bar_t *obj, nbgl_obj_t *prevObj, bool computePosition)
759{
760#ifdef HAVE_SE_TOUCH
761
762 uint8_t stroke = 3; // 3 pixels for border
763
764 if (computePosition) {
765 compute_position((nbgl_obj_t *) obj, prevObj);
766 }
767 LOG_DEBUG(OBJ_LOGGER,
768 "draw_progressBar(), x0 = %d, y0 = %d, level = %d %%\n",
769 obj->obj.area.x0,
770 obj->obj.area.y0,
771 obj->state);
772
773 // inherit background from parent
774 obj->obj.area.backgroundColor = obj->obj.parent->area.backgroundColor;
775
776 if (obj->partialRedraw == false) {
777 // Case of progress bar full draw
778 if (obj->withBorder) {
779 nbgl_drawRoundedBorderedRect((nbgl_area_t *) obj,
780 RADIUS_0_PIXELS,
781 stroke,
782 obj->obj.area.backgroundColor,
783 obj->foregroundColor);
784 }
785 else {
786 nbgl_drawRoundedRect(
787 (nbgl_area_t *) obj, RADIUS_0_PIXELS, obj->obj.area.backgroundColor);
788 }
789 // also reset previous width to be sure to clean up everything
790 obj->previousWidth = 0;
791 }
792 // Setup bar draw
793 nbgl_area_t barArea;
794 uint16_t barWidth = ((obj->state * obj->obj.area.width)) / 100;
795 int barDiffWith = barWidth - obj->previousWidth;
796 color_t barColor;
797 memcpy(&barArea, &obj->obj.area, sizeof(nbgl_area_t));
798
799 if (barDiffWith >= 0) {
800 // Drawing "forward"
801 barArea.x0 = obj->obj.area.x0 + obj->previousWidth;
802 barArea.width = barDiffWith;
803 barColor = obj->foregroundColor;
804 }
805 else {
806 // Drawing "backward"
807 barArea.x0 = obj->obj.area.x0 + obj->previousWidth + barDiffWith;
808 barArea.width = -barDiffWith;
809 barColor = obj->obj.area.backgroundColor;
810 }
811
812 if (barDiffWith != 0) {
813 nbgl_drawRoundedRect((nbgl_area_t *) &barArea, RADIUS_0_PIXELS, barColor);
814 }
815
816 // reset partialRedraw to be sure that in case of full redraw of the screen we redraw the
817 // full bar
818 if (obj->partialRedraw == true) {
819 obj->partialRedraw = false;
820 }
821 obj->previousWidth = barWidth;
822
823 extendRefreshArea(&barArea);
824 objRefreshAreaDone = true;
825#else // HAVE_SE_TOUCH
826 uint8_t stroke = 1; // 1 pixels for border
827 uint16_t levelWidth;
828
829 if (computePosition) {
830 compute_position((nbgl_obj_t *) obj, prevObj);
831 }
832 LOG_DEBUG(OBJ_LOGGER,
833 "draw_progressBar(), x0 = %d, y0 = %d, level = %d %%\n",
834 obj->obj.area.x0,
835 obj->obj.area.y0,
836 obj->state);
837
838 // inherit background from parent
839 obj->obj.area.backgroundColor = obj->obj.parent->area.backgroundColor;
840
841 // draw external part if necessary
842 if (obj->withBorder) {
843 nbgl_drawRoundedBorderedRect((nbgl_area_t *) obj,
844 RADIUS_3_PIXELS,
845 stroke,
846 obj->obj.area.backgroundColor,
847 obj->foregroundColor);
848 }
849 else {
850 nbgl_drawRoundedRect((nbgl_area_t *) obj, RADIUS_3_PIXELS, obj->obj.area.backgroundColor);
851 }
852 // draw level
853 levelWidth = MIN((obj->obj.area.width - 2) * obj->state / 100, (obj->obj.area.width - 2));
854 if (levelWidth > 0) {
855 nbgl_area_t rectArea;
856 rectArea.width = levelWidth;
857 rectArea.height = obj->obj.area.height - 2;
858 rectArea.backgroundColor = obj->foregroundColor;
859 rectArea.bpp = NBGL_BPP_1;
860 rectArea.x0 = obj->obj.area.x0 + 1;
861 rectArea.y0 = obj->obj.area.y0 + 1;
862
863 nbgl_frontDrawRect(&rectArea);
864 }
865#endif // HAVE_SE_TOUCH
866}
867
868#ifdef HAVE_SE_TOUCH
877static void draw_pageIndicator(nbgl_page_indicator_t *obj,
878 nbgl_obj_t *prevObj,
879 bool computePosition)
880{
881 nbgl_area_t rectArea;
882 uint16_t dashWidth;
883
884 // display nothing if less than two pages
885 if (obj->nbPages < 2) {
886 return;
887 }
888
889 if (obj->nbPages <= NB_MAX_PAGES_WITH_DASHES) {
890 int i;
891 // force height
892 obj->obj.area.height = 4;
893
894 if (computePosition) {
895 compute_position((nbgl_obj_t *) obj, prevObj);
896 }
897 LOG_DEBUG(OBJ_LOGGER,
898 "draw_pageIndicator(), x0 = %d, y0 = %d, page = %d/%d\n",
899 obj->obj.area.x0,
900 obj->obj.area.y0,
901 obj->activePage,
902 obj->nbPages);
903
904 // inherit background from parent
905 obj->obj.area.backgroundColor = obj->obj.parent->area.backgroundColor;
906
907 dashWidth = (obj->obj.area.width - ((obj->nbPages - 1) * INTER_DASHES)) / obj->nbPages;
908 rectArea.x0 = obj->obj.area.x0;
909 rectArea.y0 = obj->obj.area.y0;
910 rectArea.width = dashWidth;
911 rectArea.height = obj->obj.area.height;
912 rectArea.backgroundColor = obj->obj.area.backgroundColor;
913 rectArea.bpp = NBGL_BPP_1;
914 // draw dashes
915 for (i = 0; i < obj->activePage; i++) {
916 nbgl_frontDrawHorizontalLine(
917 &rectArea, 0xF, (obj->style == PROGRESSIVE_INDICATOR) ? BLACK : LIGHT_GRAY);
918 rectArea.x0 += dashWidth + INTER_DASHES;
919 }
920 nbgl_frontDrawHorizontalLine(&rectArea, 0xF, BLACK);
921 rectArea.x0 += dashWidth + INTER_DASHES;
922 i++;
923
924 for (; i < obj->nbPages; i++) {
925 nbgl_frontDrawHorizontalLine(&rectArea, 0xF, LIGHT_GRAY);
926 rectArea.x0 += dashWidth + INTER_DASHES;
927 }
928 }
929 else {
930 char navText[11]; // worst case is "ccc of nnn"
931
932 SPRINTF(navText, "%d of %d", obj->activePage + 1, obj->nbPages);
933 // force height
934 obj->obj.area.height = nbgl_getFontHeight(SMALL_REGULAR_FONT);
935 // the width must be at least 80
936 obj->obj.area.width = nbgl_getTextWidth(SMALL_REGULAR_FONT, navText);
937
938 if (computePosition) {
939 compute_position((nbgl_obj_t *) obj, prevObj);
940 }
941 LOG_DEBUG(OBJ_LOGGER,
942 "draw_pageIndicator(), x0 = %d, y0 = %d, page = %d/%d\n",
943 obj->obj.area.x0,
944 obj->obj.area.y0,
945 obj->activePage,
946 obj->nbPages);
947
948 // inherit background from parent
949 obj->obj.area.backgroundColor = obj->obj.parent->area.backgroundColor;
950
951 // draw active page
952 rectArea.x0 = obj->obj.area.x0;
953 rectArea.y0 = obj->obj.area.y0;
954 rectArea.width = obj->obj.area.width;
955 rectArea.height = obj->obj.area.height;
956 rectArea.backgroundColor = obj->obj.area.backgroundColor;
957 rectArea.bpp = NBGL_BPP_1;
958 nbgl_drawText(&rectArea, navText, strlen(navText), SMALL_REGULAR_FONT, DARK_GRAY);
959 }
960}
961#endif // HAVE_SE_TOUCH
962
971static void draw_textArea(nbgl_text_area_t *obj, nbgl_obj_t *prevObj, bool computePosition)
972{
973 nbgl_area_t rectArea;
974 uint16_t textWidth, fontHeight, lineHeight, textHeight, midHeight;
975 uint8_t line, nbLines;
976 const char *text;
977 nbgl_font_id_e fontId = obj->fontId;
978
979 if (computePosition) {
980 compute_position((nbgl_obj_t *) obj, prevObj);
981 }
982 // get the text of the button from the callback if not NULL
983 if (obj->onDrawCallback != NULL) {
984 obj->text = obj->onDrawCallback(obj->token);
985 }
986 text = obj->text;
987 if (text == NULL) {
988 return;
989 }
990
991 LOG_DEBUG(
992 OBJ_LOGGER,
993 "draw_textArea(), wrapping = %d, x0 = %d, y0 = %d, width = %d, height = %d, text = %s\n",
994 obj->wrapping,
995 obj->obj.area.x0,
996 obj->obj.area.y0,
997 obj->obj.area.width,
998 obj->obj.area.height,
999 text);
1000
1001 // inherit background from parent
1002 obj->obj.area.backgroundColor = obj->obj.parent->area.backgroundColor;
1003
1004 // draw background to make sure it's clean
1005#ifdef SCREEN_SIZE_NANO
1006 if (obj->style == INVERTED_COLORS) {
1007 obj->obj.area.backgroundColor = WHITE;
1008 rectArea.backgroundColor = BLACK;
1009 }
1010 else
1011#endif // SCREEN_SIZE_NANO
1012 {
1013 // inherit background from parent
1014 obj->obj.area.backgroundColor = obj->obj.parent->area.backgroundColor;
1015 rectArea.backgroundColor = obj->obj.area.backgroundColor;
1016 }
1017 rectArea.x0 = obj->obj.area.x0;
1018 rectArea.y0 = obj->obj.area.y0;
1019 rectArea.width = obj->obj.area.width;
1020 rectArea.height = obj->obj.area.height;
1021#ifdef SCREEN_SIZE_NANO
1022 if (obj->style == INVERTED_COLORS) {
1023 nbgl_drawRoundedRect(&rectArea, RADIUS_1_PIXEL, WHITE);
1024 }
1025 else
1026#endif // SCREEN_SIZE_NANO
1027 {
1028 nbgl_frontDrawRect(&rectArea);
1029 }
1030
1031 fontHeight = nbgl_getFontHeight(fontId);
1032 lineHeight = nbgl_getFontLineHeight(fontId);
1033 // special case of autoHideLongLine, when the text is too long for a line, draw '...' at the
1034 // beginning
1035 if (obj->autoHideLongLine == true) {
1036#ifdef BUILD_SCREENSHOTS
1037 nbgl_getTextNbLinesInWidth(fontId, text, obj->obj.area.width, obj->wrapping);
1038 store_string_infos(text,
1039 fontId,
1040 &obj->obj.area,
1041 obj->wrapping,
1042 last_nb_lines,
1043 last_nb_pages,
1044 last_bold_state);
1045#endif // BUILD_SCREENSHOTS
1046 textWidth = nbgl_getSingleLineTextWidth(fontId, text);
1047 if (textWidth > obj->obj.area.width) {
1048 uint16_t lineWidth, lineLen;
1049 uint16_t dotsWidth;
1050
1051 dotsWidth = nbgl_getTextWidth(fontId, "...");
1052 rectArea.x0 = obj->obj.area.x0;
1053 rectArea.y0 = obj->obj.area.y0 + (obj->obj.area.height - fontHeight) / 2;
1054 rectArea.width = dotsWidth;
1055 nbgl_drawText(&rectArea, "...", 3, fontId, obj->textColor);
1056 // then draw the end of text
1057 nbgl_getTextMaxLenAndWidthFromEnd(
1058 fontId, text, obj->obj.area.width - dotsWidth, &lineLen, &lineWidth);
1059 rectArea.x0 += dotsWidth;
1060 rectArea.width = lineWidth;
1061 nbgl_drawText(&rectArea,
1062 &text[nbgl_getTextLength(text) - lineLen],
1063 lineLen,
1064 obj->fontId,
1065 obj->textColor);
1066 return;
1067 }
1068 }
1069
1070 // get nb lines in the given width (depending of wrapping)
1071 nbLines = nbgl_getTextNbLinesInWidth(fontId, text, obj->obj.area.width, obj->wrapping);
1072#ifdef BUILD_SCREENSHOTS
1073 store_string_infos(
1074 text, fontId, &obj->obj.area, obj->wrapping, last_nb_lines, last_nb_pages, last_bold_state);
1075#endif // BUILD_SCREENSHOTS
1076 // saturate nb lines if nbMaxLines is greater than 0
1077 if ((obj->nbMaxLines > 0) && (obj->nbMaxLines < nbLines)) {
1078 nbLines = obj->nbMaxLines;
1079 }
1080
1081 textHeight = (nbLines - 1) * lineHeight + fontHeight;
1082
1083 midHeight = (obj->obj.area.height - textHeight) / 2;
1084#ifdef SCREEN_SIZE_NANO
1085 if (obj->style == INVERTED_COLORS) {
1086 midHeight--;
1087 }
1088#endif // SCREEN_SIZE_NANO
1089
1090 rectArea.backgroundColor = obj->obj.area.backgroundColor;
1091 rectArea.height = fontHeight;
1092 // draw each line
1093 for (line = 0; line < nbLines; line++) {
1094 uint16_t lineWidth, lineLen;
1095
1096 nbgl_getTextMaxLenAndWidth(
1097 fontId, text, obj->obj.area.width, &lineLen, &lineWidth, obj->wrapping);
1098 if (obj->textAlignment == MID_LEFT) {
1099 rectArea.x0 = obj->obj.area.x0;
1100 }
1101 else if (obj->textAlignment == CENTER) {
1102 rectArea.x0 = obj->obj.area.x0 + (obj->obj.area.width - lineWidth) / 2;
1103 }
1104 else if (obj->textAlignment == MID_RIGHT) {
1105 rectArea.x0 = obj->obj.area.x0 + obj->obj.area.width - lineWidth;
1106 }
1107 else {
1108 LOG_FATAL(OBJ_LOGGER, "Forbidden obj->textAlignment = %d\n", obj->textAlignment);
1109 }
1110 rectArea.y0 = obj->obj.area.y0 + midHeight + line * lineHeight;
1111 rectArea.width = lineWidth;
1112
1113 LOG_DEBUG(OBJ_LOGGER,
1114 "draw_textArea(), %s line %d, lineLen %d lineWidth = %d, obj.area.height = %d, "
1115 "textHeight = %d, nbMaxLines = %d, wrapping = %d\n",
1116 text + 3,
1117 line,
1118 lineLen,
1119 lineWidth,
1120 obj->obj.area.height,
1121 textHeight,
1122 obj->nbMaxLines,
1123 obj->wrapping);
1124 if ((obj->nbMaxLines == 0) || (line < (obj->nbMaxLines - 1))) {
1125 fontId = nbgl_drawText(&rectArea, text, lineLen, fontId, obj->textColor);
1126 }
1127 else {
1128#ifdef HAVE_SE_TOUCH
1129 // for last chunk, if nbMaxLines is used, replace the 3 last chars by "..."
1130 // draw line except 3 last chars
1131 nbgl_drawText(&rectArea, text, lineLen - 3, obj->fontId, obj->textColor);
1132 // draw "..." after the other chars
1133 rectArea.x0 += nbgl_getSingleLineTextWidthInLen(obj->fontId, text, lineLen - 3);
1134 rectArea.width = nbgl_getSingleLineTextWidth(obj->fontId, "...");
1135 nbgl_drawText(&rectArea, "...", 3, obj->fontId, obj->textColor);
1136#else // HAVE_SE_TOUCH
1137 nbgl_drawText(&rectArea, text, lineLen, fontId, obj->textColor);
1138#endif // HAVE_SE_TOUCH
1139 return;
1140 }
1141 text += lineLen;
1142 /* skip trailing \n */
1143 if (*text == '\n') {
1144 text++;
1145 }
1146 }
1147}
1148
1149#ifdef NBGL_QRCODE
1158static void draw_qrCode(nbgl_qrcode_t *obj, nbgl_obj_t *prevObj, bool computePosition)
1159{
1160 nbgl_area_t rectArea;
1161
1162 if (computePosition) {
1163 compute_position((nbgl_obj_t *) obj, prevObj);
1164 }
1165 // be sure to align vertical position on multiple of 4
1166 obj->obj.area.y0 &= ~0x3;
1167 LOG_DEBUG(OBJ_LOGGER,
1168 "draw_qrCode(), x0 = %d, y0 = %d, width = %d, height = %d, text = %s\n",
1169 obj->obj.area.x0,
1170 obj->obj.area.y0,
1171 obj->obj.area.width,
1172 obj->obj.area.height,
1173 obj->text);
1174
1175 // inherit background from parent
1176 obj->obj.area.backgroundColor = obj->obj.parent->area.backgroundColor;
1177
1178 rectArea.x0 = obj->obj.area.x0;
1179 rectArea.y0 = obj->obj.area.y0;
1180 rectArea.width = obj->obj.area.width;
1181 rectArea.height = obj->obj.area.height;
1182 rectArea.backgroundColor = obj->obj.area.backgroundColor;
1183 nbgl_drawQrCode(&rectArea, obj->version, obj->text, obj->foregroundColor);
1184}
1185#endif // NBGL_QRCODE
1186
1187#ifdef NBGL_KEYBOARD
1195static void draw_keyboard(nbgl_keyboard_t *obj, nbgl_obj_t *prevObj, bool computePosition)
1196{
1197#ifndef HAVE_SE_TOUCH
1198 obj->obj.area.width = KEYBOARD_WIDTH;
1199 obj->obj.area.height = KEYBOARD_KEY_HEIGHT;
1200#endif // HAVE_SE_TOUCH
1201
1202 if (computePosition) {
1203 compute_position((nbgl_obj_t *) obj, prevObj);
1204 }
1205 LOG_DEBUG(
1206 OBJ_LOGGER, "draw_keyboard(), x0 = %d, y0 = %d\n", obj->obj.area.x0, obj->obj.area.y0);
1207
1208 // inherit background from parent
1209 obj->obj.area.backgroundColor = obj->obj.parent->area.backgroundColor;
1210
1211 nbgl_objDrawKeyboard(obj);
1212}
1213#endif // NBGL_KEYBOARD
1214
1215#ifdef NBGL_KEYPAD
1223static void draw_keypad(nbgl_keypad_t *obj, nbgl_obj_t *prevObj, bool computePosition)
1224{
1225#ifndef HAVE_SE_TOUCH
1226 obj->obj.area.height = KEYPAD_HEIGHT;
1227 obj->obj.area.width = KEYPAD_WIDTH;
1228#endif // HAVE_SE_TOUCH
1229
1230 if (computePosition) {
1231 compute_position((nbgl_obj_t *) obj, prevObj);
1232 }
1233 obj->obj.area.y0 &= ~0x3;
1234 LOG_DEBUG(OBJ_LOGGER, "draw_keypad(), x0 = %d, y0 = %d\n", obj->obj.area.x0, obj->obj.area.y0);
1235
1236 // inherit background from parent
1237 obj->obj.area.backgroundColor = obj->obj.parent->area.backgroundColor;
1238
1239 nbgl_objDrawKeypad(obj);
1240}
1241#endif // NBGL_KEYPAD
1242
1243#ifdef HAVE_SE_TOUCH
1251static void draw_spinner(nbgl_spinner_t *obj, nbgl_obj_t *prevObj, bool computePosition)
1252{
1253 nbgl_area_t rectArea;
1254 color_t foreColor;
1255
1256 obj->obj.area.width = SPINNER_WIDTH;
1257 obj->obj.area.height = SPINNER_HEIGHT;
1258
1259 if (computePosition) {
1260 compute_position((nbgl_obj_t *) obj, prevObj);
1261 }
1262 obj->obj.area.y0 &= ~0x3;
1263 LOG_DEBUG(OBJ_LOGGER, "draw_spinner(), x0 = %d, y0 = %d\n", obj->obj.area.x0, obj->obj.area.y0);
1264
1265 // inherit background from parent
1266 obj->obj.area.backgroundColor = obj->obj.parent->area.backgroundColor;
1267 // foreground color is the opposite of background one
1268 foreColor = (obj->obj.area.backgroundColor == WHITE) ? BLACK : WHITE;
1269
1270 rectArea.bpp = NBGL_BPP_1;
1271 rectArea.backgroundColor = obj->obj.area.backgroundColor;
1272 // if position is OxFF, it means "fixed" so draw 4 corners
1273 if (obj->position == 0xFF) {
1274 // draw horizontal segments
1275 rectArea.x0 = obj->obj.area.x0;
1276 rectArea.y0 = obj->obj.area.y0;
1277 rectArea.width = 20;
1278 rectArea.height = 4;
1279 nbgl_frontDrawHorizontalLine(&rectArea, 0x7, foreColor); // top left
1280 rectArea.x0 = obj->obj.area.x0 + obj->obj.area.width - rectArea.width;
1281 nbgl_frontDrawHorizontalLine(&rectArea, 0x7, foreColor); // top right
1282 rectArea.y0 = obj->obj.area.y0 + obj->obj.area.height - 4;
1283 nbgl_frontDrawHorizontalLine(&rectArea, 0xE, foreColor); // bottom right
1284 rectArea.x0 = obj->obj.area.x0;
1285 nbgl_frontDrawHorizontalLine(&rectArea, 0xE, foreColor); // bottom left
1286 // draw vertical segments
1287 rectArea.x0 = obj->obj.area.x0;
1288 rectArea.y0 = obj->obj.area.y0;
1289 rectArea.width = 3;
1290 rectArea.height = 12;
1291 rectArea.backgroundColor = foreColor;
1292 nbgl_frontDrawRect(&rectArea); // top left
1293 rectArea.x0 = obj->obj.area.x0 + obj->obj.area.width - rectArea.width;
1294 nbgl_frontDrawRect(&rectArea); // top right
1295 rectArea.y0 = obj->obj.area.y0 + obj->obj.area.height - rectArea.height;
1296 nbgl_frontDrawRect(&rectArea); // bottom right
1297 rectArea.x0 = obj->obj.area.x0;
1298 nbgl_frontDrawRect(&rectArea); // bottom left
1299 }
1300 else {
1301 uint8_t mask;
1302 // clean up full rectangle
1303 rectArea.x0 = obj->obj.area.x0;
1304 rectArea.y0 = obj->obj.area.y0;
1305 rectArea.width = obj->obj.area.width;
1306 rectArea.height = obj->obj.area.height;
1307 rectArea.backgroundColor = obj->obj.area.backgroundColor;
1308 nbgl_frontDrawRect(&rectArea); // top left
1309
1310 // draw horizontal segment in foreColor
1311 rectArea.width = 20;
1312 rectArea.height = 4;
1313 switch (obj->position) {
1314 case 0: // top left corner
1315 rectArea.x0 = obj->obj.area.x0;
1316 rectArea.y0 = obj->obj.area.y0;
1317 mask = 0x7;
1318 break;
1319 case 1: // top right
1320 rectArea.x0 = obj->obj.area.x0 + obj->obj.area.width - rectArea.width;
1321 rectArea.y0 = obj->obj.area.y0;
1322 mask = 0x7;
1323 break;
1324 case 2: // bottom right
1325 rectArea.x0 = obj->obj.area.x0 + obj->obj.area.width - rectArea.width;
1326 rectArea.y0 = obj->obj.area.y0 + obj->obj.area.height - 4;
1327 mask = 0xE;
1328 break;
1329 case 3: // bottom left
1330 rectArea.x0 = obj->obj.area.x0;
1331 rectArea.y0 = obj->obj.area.y0 + obj->obj.area.height - 4;
1332 mask = 0xE;
1333 break;
1334 default:
1335 return;
1336 }
1337 nbgl_frontDrawHorizontalLine(&rectArea, mask, foreColor);
1338
1339 // draw vertical segment in foreColor
1340 rectArea.width = 3;
1341 rectArea.height = 12;
1342 rectArea.backgroundColor = foreColor;
1343 switch (obj->position) {
1344 case 0: // top left corner
1345 rectArea.x0 = obj->obj.area.x0;
1346 rectArea.y0 = obj->obj.area.y0;
1347 break;
1348 case 1: // top right corner
1349 rectArea.x0 = obj->obj.area.x0 + obj->obj.area.width - rectArea.width;
1350 rectArea.y0 = obj->obj.area.y0;
1351 break;
1352 case 2: // bottom right corner
1353 rectArea.x0 = obj->obj.area.x0 + obj->obj.area.width - rectArea.width;
1354 rectArea.y0 = obj->obj.area.y0 + obj->obj.area.height - rectArea.height;
1355 break;
1356 case 3: // bottom left corner
1357 rectArea.x0 = obj->obj.area.x0;
1358 rectArea.y0 = obj->obj.area.y0 + obj->obj.area.height - rectArea.height;
1359 break;
1360 default:
1361 return;
1362 }
1363 nbgl_frontDrawRect(&rectArea);
1364 }
1365}
1366
1367#else // HAVE_SE_TOUCH
1368
1376static void draw_textEntry(nbgl_text_entry_t *obj, nbgl_obj_t *prevObj, bool computePosition)
1377{
1378 nbgl_area_t rectArea;
1379 int textLen = strlen(obj->text);
1380 uint32_t offsetX;
1381
1382 if (computePosition) {
1383 compute_position((nbgl_obj_t *) obj, prevObj);
1384 }
1385
1386 LOG_DEBUG(OBJ_LOGGER,
1387 "draw_textEntry(), x0 = %d, y0 = %d, width = %d, height = %d\n",
1388 obj->obj.area.x0,
1389 obj->obj.area.y0,
1390 obj->obj.area.width,
1391 obj->obj.area.height);
1392
1393 // draw background to make sure it's clean
1394 obj->obj.area.backgroundColor = WHITE;
1395 rectArea.backgroundColor = BLACK;
1396 rectArea.x0 = obj->obj.area.x0;
1397 rectArea.y0 = obj->obj.area.y0;
1398 rectArea.width = obj->obj.area.width;
1399 rectArea.height = obj->obj.area.height;
1400 rectArea.bpp = NBGL_BPP_1;
1401 nbgl_drawRoundedRect(&rectArea, RADIUS_3_PIXELS, WHITE);
1402
1403 rectArea.backgroundColor = obj->obj.area.backgroundColor;
1404 rectArea.height = nbgl_getFontHeight(obj->fontId);
1405 if (obj->nbChars > NB_MAX_LETTERS) {
1406 return;
1407 }
1408 offsetX = (obj->obj.area.width - (obj->nbChars * 10)) / 2;
1409 // draw each of the nb chars
1410 for (int i = 0; i < obj->nbChars; i++) {
1411 char digit;
1412 rectArea.x0 = obj->obj.area.x0 + offsetX + (i * 10);
1413 rectArea.y0 = obj->obj.area.y0 - 2;
1414 rectArea.width = 8;
1415 if (textLen < obj->nbChars) {
1416 if (i < textLen) {
1417 digit = obj->text[i];
1418 }
1419 else {
1420 digit = '_';
1421 }
1422 }
1423 else {
1424 // first char is '..' to notify continuing
1425 if (i == 0) {
1426 nbgl_drawText(&rectArea, "..", 2, BAGL_FONT_OPEN_SANS_EXTRABOLD_11px_1bpp, BLACK);
1427 continue;
1428 }
1429 else if (i < (obj->nbChars - 1)) {
1430 digit = obj->text[textLen - obj->nbChars + 1 + i];
1431 }
1432 else {
1433 digit = '_';
1434 }
1435 }
1436 nbgl_drawText(&rectArea, &digit, 1, BAGL_FONT_OPEN_SANS_EXTRABOLD_11px_1bpp, BLACK);
1437 }
1438}
1439#endif // HAVE_SE_TOUCH
1440
1448static void draw_image_file(nbgl_image_file_t *obj, nbgl_obj_t *prevObj, bool computePosition)
1449{
1450 if (obj->buffer == NULL) {
1451 return;
1452 }
1453 if (computePosition) {
1454 compute_position((nbgl_obj_t *) obj, prevObj);
1455 }
1456
1457 LOG_DEBUG(
1458 OBJ_LOGGER, "draw_image_file(), x0 = %d, y0 = %d\n", obj->obj.area.x0, obj->obj.area.y0);
1459 obj->obj.area.backgroundColor = WHITE;
1460 nbgl_frontDrawImageFile((nbgl_area_t *) obj, obj->buffer, BLACK, ramBuffer);
1461}
1462
1463#ifdef NBGL_MASKING
1464static void draw_mask_control(nbgl_mask_control_t *obj, nbgl_obj_t *prevObj, bool computePosition)
1465{
1466 if (computePosition) {
1467 compute_position((nbgl_obj_t *) obj, prevObj);
1468 }
1469
1470 if (obj->enableMasking) {
1471 nbgl_frontControlAreaMasking(obj->maskIndex, &obj->obj.area);
1472 }
1473 else {
1474 nbgl_frontControlAreaMasking(obj->maskIndex, NULL);
1475 }
1476}
1477#endif // NBGL_MASKING
1478
1486static void draw_object(nbgl_obj_t *obj, nbgl_obj_t *prevObj, bool computePosition)
1487{
1488 LOG_DEBUG(OBJ_LOGGER, "draw_object() obj->type = %d, prevObj = %p\n", obj->type, prevObj);
1489 objRefreshAreaDone = false;
1490 if ((obj->type < NB_OBJ_TYPES) && (draw_functions[obj->type] != NULL)) {
1491 draw_function_t func = (draw_function_t) PIC(draw_functions[obj->type]);
1492 func(obj, prevObj, computePosition);
1493 }
1494 else {
1495 LOG_DEBUG(OBJ_LOGGER, "Not existing object type\n");
1496 return;
1497 }
1498
1499#ifdef HAVE_SERIALIZED_NBGL
1500 io_seproxyhal_send_nbgl_serialized(NBGL_DRAW_OBJ, obj);
1501#endif
1502 if (!objRefreshAreaDone) {
1503 extendRefreshArea(&obj->area);
1504 }
1505}
1506
1516static void draw_obj_and_chidren(nbgl_obj_t *obj, nbgl_obj_t *prevObj, bool computePosition)
1517{
1518 uint8_t i = 0;
1519 LOG_DEBUG(OBJ_LOGGER, "draw_obj_and_chidren(): obj = %p\n", obj);
1520 // draw the object itself
1521 draw_object(obj, prevObj, computePosition);
1522
1523 if ((obj->type == SCREEN) || (obj->type == CONTAINER)) {
1524 nbgl_container_t *container = (nbgl_container_t *) obj;
1525 nbgl_obj_t *prev = NULL;
1526 LOG_DEBUG(
1527 OBJ_LOGGER, "draw_obj_and_chidren(): container->children = %p\n", container->children);
1528 // draw the children, if any
1529 if (container->children != NULL) {
1530 for (i = 0; i < container->nbChildren; i++) {
1531 nbgl_obj_t *current = container->children[i];
1532 if (current != NULL) {
1533 current->parent = (nbgl_obj_t *) container;
1534 draw_obj_and_chidren(current, prev, true);
1535 if (current->alignTo == NULL) {
1536 prev = current;
1537 }
1538 }
1539 }
1540 }
1541 }
1542}
1543
1550static void extendRefreshArea(nbgl_area_t *area)
1551{
1552 int16_t x1, y1; // bottom right corner
1553 x1 = refreshArea.x0 + refreshArea.width;
1554 y1 = refreshArea.y0 + refreshArea.height;
1555
1556 // if obj top-left is on left of current top-left corner, move top-left corner
1557 if (area->x0 < refreshArea.x0) {
1558 // No negative coordinates
1559 refreshArea.x0 = MAX(0, area->x0);
1560 }
1561 // if obj bottom-right is on right of current bottom-right corner, move bottom-right corner
1562 if (((area->x0 + area->width) > x1) || (refreshArea.width == 0)) {
1563 // Not beyond width
1564 x1 = MIN(SCREEN_WIDTH, area->x0 + area->width);
1565 }
1566 // if obj top-left is on top of current top-left corner, move top-left corner
1567 if (area->y0 < refreshArea.y0) {
1568 // No negative coordinates and align on lower multiple of alignment
1569 refreshArea.y0 = MAX(0, area->y0) & ~(VERTICAL_ALIGNMENT - 1);
1570 }
1571 // if obj bottom-right is on bottom of current bottom-right corner, move bottom-right corner
1572 if (((area->y0 + area->height) > y1) || (refreshArea.height == 0)) {
1573 // Not beyond height
1574 y1 = MIN(SCREEN_HEIGHT, area->y0 + area->height);
1575 // align on upper multiple of alignment
1576 y1 = (y1 + (VERTICAL_ALIGNMENT - 1)) & ~(VERTICAL_ALIGNMENT - 1);
1577 }
1578
1579 // sanity check
1580 if (x1 > SCREEN_WIDTH) {
1581 LOG_FATAL(OBJ_LOGGER,
1582 "extendRefreshArea: Impossible area x0 = %d width %d\n",
1583 refreshArea.x0,
1584 refreshArea.width);
1585 }
1586 if (y1 > SCREEN_HEIGHT) {
1587#ifdef HAVE_SE_TOUCH
1588 LOG_FATAL(OBJ_LOGGER,
1589 "extendRefreshArea: Impossible area y0 = %d height %d\n",
1590 refreshArea.y0,
1591 refreshArea.height);
1592#else // HAVE_SE_TOUCH
1593 y1 = SCREEN_HEIGHT;
1594#endif // HAVE_SE_TOUCH
1595 }
1596 // recompute width and height
1597 refreshArea.width = x1 - refreshArea.x0;
1598 refreshArea.height = y1 - refreshArea.y0;
1599
1600 // revaluate area bpp
1601 if (area->bpp > refreshArea.bpp) {
1602 refreshArea.bpp = area->bpp;
1603 }
1604}
1605
1611void nbgl_objDraw(nbgl_obj_t *obj)
1612{
1613 bool computePosition = false;
1614 bool fromApp;
1615
1616 LOG_DEBUG(OBJ_LOGGER, "nbgl_objDraw(): obj = %p\n", obj);
1617 // check whether it's necessary to compute position, and if this object belongs to
1618 // an Application screen
1619 if (obj->type == SCREEN) {
1620 // always compute position for screen and all sub-objects
1621 computePosition = true;
1622 fromApp = !(((nbgl_screen_t *) obj)->isUxScreen);
1623 }
1624 else {
1625 nbgl_obj_t *parent = obj;
1626 // search screen in parenthood
1627 while (parent->parent != NULL) {
1628 parent = parent->parent;
1629 }
1630 if (parent->type == SCREEN) {
1631 fromApp = !(((nbgl_screen_t *) parent)->isUxScreen);
1632 }
1633 else {
1634 // should never happen
1635 fromApp = false;
1636 }
1637 }
1638 // actually draw the object and its children, if it is allowed
1639 if (objDrawingDisabled && fromApp) {
1640 return;
1641 }
1642 draw_obj_and_chidren(obj, NULL, computePosition);
1643}
1644
1654
1660void nbgl_refreshSpecial(nbgl_refresh_mode_t mode)
1661{
1662 if ((refreshArea.width == 0) || (refreshArea.height == 0)) {
1663 return;
1664 }
1665
1666 nbgl_frontRefreshArea(&refreshArea, mode, POST_REFRESH_FORCE_POWER_OFF);
1667 LOG_DEBUG(OBJ_LOGGER,
1668 "nbgl_refreshSpecial(), x0,y0 = [%d, %d], w,h = [%d, %d]\n",
1669 refreshArea.x0,
1670 refreshArea.y0,
1671 refreshArea.width,
1672 refreshArea.height);
1673 nbgl_refreshReset();
1674}
1675
1676void nbgl_refreshSpecialWithPostRefresh(nbgl_refresh_mode_t mode, nbgl_post_refresh_t post_refresh)
1677{
1678 if ((refreshArea.width == 0) || (refreshArea.height == 0)) {
1679 return;
1680 }
1681
1682 nbgl_frontRefreshArea(&refreshArea, mode, post_refresh);
1683 LOG_DEBUG(OBJ_LOGGER,
1684 "nbgl_refreshSpecialNoPoff(), x0,y0 = [%d, %d], w,h = [%d, %d]\n",
1685 refreshArea.x0,
1686 refreshArea.y0,
1687 refreshArea.width,
1688 refreshArea.height);
1689 nbgl_refreshReset();
1690}
1691
1696bool nbgl_refreshIsNeeded(void)
1697{
1698 if ((refreshArea.width == 0) || (refreshArea.height == 0)) {
1699 return false;
1700 }
1701 return true;
1702}
1703
1708void nbgl_refreshReset(void)
1709{
1710#ifdef HAVE_SERIALIZED_NBGL
1711 io_seproxyhal_send_nbgl_serialized(NBGL_REFRESH_AREA, (nbgl_obj_t *) &refreshArea);
1712#endif
1713 refreshArea.x0 = SCREEN_WIDTH - 1;
1714 refreshArea.width = 0;
1715 refreshArea.y0 = SCREEN_HEIGHT - 1;
1716 refreshArea.height = 0;
1717 refreshArea.bpp = NBGL_BPP_2;
1718}
1719
1725void nbgl_objInit(void)
1726{
1727 // init area to the smallest size
1728 nbgl_refreshReset();
1729 objDrawingDisabled = false;
1730#ifdef HAVE_SE_TOUCH
1731 nbgl_touchInit(false);
1732#endif
1733}
1734
1740void nbgl_objAllowDrawing(bool enable)
1741{
1742 objDrawingDisabled = !enable;
1743}
1744
1750uint8_t *nbgl_objGetRAMBuffer(void)
1751{
1752 return ramBuffer;
1753}
1754
1760bool nbgl_objIsUx(nbgl_obj_t *obj)
1761{
1762 nbgl_obj_t *parent = obj;
1763 // search screen in parenthood
1764 while (parent->parent != NULL) {
1765 parent = parent->parent;
1766 }
1767 if (parent->type == SCREEN) {
1768 return (((nbgl_screen_t *) parent)->isUxScreen);
1769 }
1770 else {
1771 // should never happen
1772 return true;
1773 }
1774}
nbgl_debug.h
debug traces management
LOG_WARN
#define LOG_WARN(__logger,...)
Definition nbgl_debug.h:87
LOG_DEBUG
#define LOG_DEBUG(__logger,...)
Definition nbgl_debug.h:86
LOG_FATAL
#define LOG_FATAL(__logger,...)
Definition nbgl_debug.h:88
OBJ_LOGGER
@ OBJ_LOGGER
Definition nbgl_debug.h:30
nbgl_draw.h
Middle Level API of the new BOLOS Graphical Library.
nbgl_drawIcon
void nbgl_drawIcon(nbgl_area_t *area, nbgl_transformation_t transformation, nbgl_color_map_t color_map, const nbgl_icon_details_t *icon)
Helper function to render an icon directly from its nbgl_icon_details_t structure.
Definition nbgl_draw.c:489
nbgl_drawText
nbgl_font_id_e nbgl_drawText(const nbgl_area_t *area, const char *text, uint16_t textLen, nbgl_font_id_e fontId, color_t fontColor)
This function draws the given single-line text, with the given parameters.
Definition nbgl_draw.c:538
nbgl_drawRoundedBorderedRect
void nbgl_drawRoundedBorderedRect(const nbgl_area_t *area, nbgl_radius_t radius, uint8_t stroke, color_t innerColor, color_t borderColor)
This functions draws a rounded corners rectangle with a border, with the given parameters.
Definition nbgl_draw.c:331
nbgl_drawQrCode
void nbgl_drawQrCode(const nbgl_area_t *area, nbgl_qrcode_version_t version, const char *text, color_t backgroundColor)
Draws the given text into a V10 QR code (QR code version is fixed using qrcodegen_VERSION_MIN/qrcodeg...
Definition nbgl_draw.c:764
nbgl_drawRoundedRect
void nbgl_drawRoundedRect(const nbgl_area_t *area, nbgl_radius_t radius, color_t innerColor)
This functions draws a rounded corners rectangle (without border), with the given parameters.
Definition nbgl_draw.c:249
nbgl_getTextMaxLenAndWidth
void nbgl_getTextMaxLenAndWidth(nbgl_font_id_e fontId, const char *text, uint16_t maxWidth, uint16_t *len, uint16_t *width, bool wrapping)
compute the max width of the first line of the given text fitting in maxWidth
Definition nbgl_fonts.c:472
nbgl_getSingleLineTextWidth
uint16_t nbgl_getSingleLineTextWidth(nbgl_font_id_e fontId, const char *text)
return the max width in pixels of the given text until the first or \0 is encountered
Definition nbgl_fonts.c:324
nbgl_font_id_e
nbgl_font_id_e
Definition nbgl_fonts.h:136
BAGL_FONT_OPEN_SANS_EXTRABOLD_11px_1bpp
@ BAGL_FONT_OPEN_SANS_EXTRABOLD_11px_1bpp
Definition nbgl_fonts.h:143
nbgl_getTextMaxLenAndWidthFromEnd
bool nbgl_getTextMaxLenAndWidthFromEnd(nbgl_font_id_e fontId, const char *text, uint16_t maxWidth, uint16_t *len, uint16_t *width)
compute the len and width of the given text fitting in the maxWidth, starting from end of text
Definition nbgl_fonts.c:671
nbgl_getFontHeight
uint8_t nbgl_getFontHeight(nbgl_font_id_e fontId)
return the height in pixels of the font with the given font ID
Definition nbgl_fonts.c:388
nbgl_getTextWidth
uint16_t nbgl_getTextWidth(nbgl_font_id_e fontId, const char *text)
return the max width in pixels of the given text (can be multiline)
Definition nbgl_fonts.c:350
nbgl_getTextLength
uint16_t nbgl_getTextLength(const char *text)
return the number of bytes of the given text, excluding final ' ' or '\0'
Definition nbgl_fonts.c:444
nbgl_getTextNbLinesInWidth
uint16_t nbgl_getTextNbLinesInWidth(nbgl_font_id_e fontId, const char *text, uint16_t maxWidth, bool wrapping)
compute the number of lines of the given text fitting in the given maxWidth
Definition nbgl_fonts.c:721
nbgl_getFontLineHeight
uint8_t nbgl_getFontLineHeight(nbgl_font_id_e fontId)
return the height in pixels of the line of font with the given font ID
Definition nbgl_fonts.c:400
nbgl_getSingleLineTextWidthInLen
uint16_t nbgl_getSingleLineTextWidthInLen(nbgl_font_id_e fontId, const char *text, uint16_t maxLen)
return the max width in pixels of the given text until the first or \0 is encountered,...
Definition nbgl_fonts.c:338
nbgl_front.h
Font screen low-Level driver API, to draw elementary forms.
nbgl_frontControlAreaMasking
void nbgl_frontControlAreaMasking(uint8_t mask_index, nbgl_area_t *masked_area_or_null)
nbgl_frontDrawImage
void nbgl_frontDrawImage(const nbgl_area_t *area, const uint8_t *buffer, nbgl_transformation_t transformation, nbgl_color_map_t colorMap)
nbgl_frontDrawImageFile
void nbgl_frontDrawImageFile(const nbgl_area_t *area, const uint8_t *buffer, nbgl_color_map_t colorMap, const uint8_t *uzlib_chunk_buffer)
nbgl_frontRefreshArea
void nbgl_frontRefreshArea(const nbgl_area_t *area, nbgl_refresh_mode_t mode, nbgl_post_refresh_t post_refresh)
nbgl_frontDrawHorizontalLine
void nbgl_frontDrawHorizontalLine(const nbgl_area_t *area, uint8_t mask, color_t lineColor)
nbgl_frontDrawRect
void nbgl_frontDrawRect(const nbgl_area_t *area)
ICON_TEXT_SPACE
#define ICON_TEXT_SPACE
NB_MAX_LETTERS
#define NB_MAX_LETTERS
Definition nbgl_obj.c:34
nbgl_objDraw
void nbgl_objDraw(nbgl_obj_t *obj)
This function draws or redraws the given object and its children (recursive version)
Definition nbgl_obj.c:1611
nbgl_refresh
void nbgl_refresh(void)
This functions refreshes the actual screen on display with what has changed since the last refresh.
Definition nbgl_obj.c:1650
nbgl_refreshReset
void nbgl_refreshReset(void)
This functions resets all changes since the last refresh.
Definition nbgl_obj.c:1708
nbgl_objAllowDrawing
void nbgl_objAllowDrawing(bool enable)
This functions enables or disables drawing/refresh for all further calls.
Definition nbgl_obj.c:1740
draw_function_t
void(* draw_function_t)(nbgl_obj_t *obj, nbgl_obj_t *prevObj, bool computePosition)
Definition nbgl_obj.c:45
nbgl_refreshSpecial
void nbgl_refreshSpecial(nbgl_refresh_mode_t mode)
This functions refreshes the actual screen on display with what has changed since the last refresh,...
Definition nbgl_obj.c:1660
nbgl_objIsUx
bool nbgl_objIsUx(nbgl_obj_t *obj)
This function returns true if the object belongs to a UxScreen.
Definition nbgl_obj.c:1760
get_ux_loc_string
const char * get_ux_loc_string(uint32_t index)
nbgl_refreshSpecialWithPostRefresh
void nbgl_refreshSpecialWithPostRefresh(nbgl_refresh_mode_t mode, nbgl_post_refresh_t post_refresh)
Definition nbgl_obj.c:1676
nbgl_objGetRAMBuffer
uint8_t * nbgl_objGetRAMBuffer(void)
This function is used to get the all purpose RAM buffer.
Definition nbgl_obj.c:1750
ramBuffer
uint8_t ramBuffer[GZLIB_UNCOMPRESSED_CHUNK]
Definition nbgl_obj.c:131
nbgl_refreshIsNeeded
bool nbgl_refreshIsNeeded(void)
This functions returns true if there is something to refresh.
Definition nbgl_obj.c:1696
nbgl_objInit
void nbgl_objInit(void)
This functions inits all internal of nbgl objects layer.
Definition nbgl_obj.c:1725
nbgl_obj.h
API to draw all basic graphic objects.
nbgl_line_t
struct PACKED__ nbgl_line_s nbgl_line_t
struct to represent a vertical or horizontal line
nbgl_page_indicator_t
struct PACKED__ nbgl_navigation_bar_s nbgl_page_indicator_t
struct to represent a navigation bar (PAGE_INDICATOR type) There can be up to 5 page indicators,...
nbgl_radio_t
struct PACKED__ nbgl_radio_s nbgl_radio_t
struct to represent a radio button (RADIO_BUTTON type)
nbgl_text_area_t
struct PACKED__ nbgl_text_area_s nbgl_text_area_t
struct to represent a text area (TEXT_AREA type)
nbgl_progress_bar_t
struct PACKED__ nbgl_progress_bar_s nbgl_progress_bar_t
struct to represent a progress bar (PROGRESS_BAR type)
nbgl_keypad_t
struct PACKED__ nbgl_keypad_s nbgl_keypad_t
struct to represent a keypad (KEYPAD type)
nbgl_mask_control_t
struct PACKED__ nbgl_mask_control_s nbgl_mask_control_t
nbgl_text_entry_t
struct PACKED__ nbgl_text_entry_s nbgl_text_entry_t
struct to represent a text entry area (TEXT_ENTRY type)
nbgl_keyboard_t
struct PACKED__ nbgl_keyboard_s nbgl_keyboard_t
struct to represent a keyboard (KEYBOARD type)
nbgl_image_t
struct PACKED__ nbgl_image_s nbgl_image_t
struct to represent an image (IMAGE type)
nbgl_button_t
struct PACKED__ nbgl_button_s nbgl_button_t
struct to represent a button (BUTTON type) that can contain a text and/or an icon
nbgl_objDrawKeyboard
void nbgl_objDrawKeyboard(nbgl_keyboard_t *kbd)
This function draws a keyboard object.
Definition nbgl_obj_keyboard.c:692
NB_MAX_PAGES_WITH_DASHES
#define NB_MAX_PAGES_WITH_DASHES
Definition nbgl_obj.h:182
nbgl_objDrawKeypad
void nbgl_objDrawKeypad(nbgl_keypad_t *kbd)
This function draws a keypad object.
Definition nbgl_obj_keypad.c:387
nbgl_container_t
struct PACKED__ nbgl_container_s nbgl_container_t
struct to represent a container (CONTAINER type)
PROGRESSIVE_INDICATOR
@ PROGRESSIVE_INDICATOR
all dashes before active page are black
Definition nbgl_obj.h:388
nbgl_switch_t
struct PACKED__ nbgl_switch_s nbgl_switch_t
struct to represent a switch (size is fixed) (SWITCH type)
nbgl_obj_t
struct PACKED__ nbgl_obj_s nbgl_obj_t
Common structure for all graphical objects.
nbgl_spinner_t
struct PACKED__ nbgl_spinner_s nbgl_spinner_t
struct to represent a "spinner", represented by the Ledger corners, in gray, with one of the corners ...
nbgl_image_file_t
struct PACKED__ nbgl_image_file_s nbgl_image_file_t
struct to represent an image file object (IMAGE_FILE type) The source of the data is an image file wi...
nbgl_qrcode_t
struct PACKED__ nbgl_qrcode_s nbgl_qrcode_t
struct to represent a QR code (QR_CODE type), whose size is fixed
nbgl_screen.h
API to manage screens.
nbgl_screen_t
struct PACKED__ nbgl_screen_s nbgl_screen_t
struct to represent a screen (SCREEN type)
nbgl_serialize.h
NBGL_DRAW_OBJ
@ NBGL_DRAW_OBJ
Definition nbgl_serialize.h:9
NBGL_REFRESH_AREA
@ NBGL_REFRESH_AREA
Definition nbgl_serialize.h:10
nbgl_touch.h
nbgl_touchInit
void nbgl_touchInit(bool fromUx)
Function to initialize the touch context.
Definition nbgl_touch.c:274
color_t
color_t
Definition nbgl_types.h:122
WHITE
@ WHITE
Definition nbgl_types.h:126
DARK_GRAY
@ DARK_GRAY
Definition nbgl_types.h:124
LIGHT_GRAY
@ LIGHT_GRAY
Definition nbgl_types.h:125
BLACK
@ BLACK
Definition nbgl_types.h:123
OFF_STATE
@ OFF_STATE
Definition nbgl_types.h:182
nbgl_post_refresh_t
nbgl_post_refresh_t
Post refresh modes.
Definition nbgl_types.h:334
POST_REFRESH_FORCE_POWER_OFF
@ POST_REFRESH_FORCE_POWER_OFF
Force screen power off after refresh.
Definition nbgl_types.h:335
VERTICAL_MIRROR
#define VERTICAL_MIRROR
Definition nbgl_types.h:82
nbgl_color_map_t
uint8_t nbgl_color_map_t
Represents the color_map to be used for 2BPP image, or the foreground color for 1BPP image.
Definition nbgl_types.h:371
RADIUS_0_PIXELS
@ RADIUS_0_PIXELS
no radius (square angle)
Definition nbgl_types.h:357
VERTICAL
@ VERTICAL
from top to bottom
Definition nbgl_types.h:191
MIN
#define MIN(x, y)
Definition nbgl_types.h:100
nbgl_icon_details_t
struct PACKED__ nbgl_icon_details_s nbgl_icon_details_t
Represents all information about an icon.
GZLIB_UNCOMPRESSED_CHUNK
#define GZLIB_UNCOMPRESSED_CHUNK
size of gzlib uncompression buffer in bytes
Definition nbgl_types.h:287
TOP_MIDDLE
@ TOP_MIDDLE
Definition nbgl_types.h:164
CENTER
@ CENTER
Definition nbgl_types.h:167
BOTTOM_RIGHT
@ BOTTOM_RIGHT
Definition nbgl_types.h:171
TOP_LEFT
@ TOP_LEFT
Definition nbgl_types.h:163
NO_ALIGNMENT
@ NO_ALIGNMENT
used when parent container layout is used
Definition nbgl_types.h:162
BOTTOM_LEFT
@ BOTTOM_LEFT
Definition nbgl_types.h:169
LEFT_TOP
@ LEFT_TOP
on outside left
Definition nbgl_types.h:172
LEFT_BOTTOM
@ LEFT_BOTTOM
on outside left
Definition nbgl_types.h:173
MID_RIGHT
@ MID_RIGHT
Definition nbgl_types.h:168
RIGHT_TOP
@ RIGHT_TOP
on outside right
Definition nbgl_types.h:174
TOP_RIGHT
@ TOP_RIGHT
Definition nbgl_types.h:165
MID_LEFT
@ MID_LEFT
Definition nbgl_types.h:166
BOTTOM_MIDDLE
@ BOTTOM_MIDDLE
Definition nbgl_types.h:170
RIGHT_BOTTOM
@ RIGHT_BOTTOM
on outside right
Definition nbgl_types.h:175
KEYPAD
@ KEYPAD
Keypad.
Definition nbgl_types.h:149
IMAGE
@ IMAGE
Bitmap (y and height must be multiple of 4 on Stax)
Definition nbgl_types.h:139
IMAGE_FILE
@ IMAGE_FILE
Image file (with Ledger compression)
Definition nbgl_types.h:151
TEXT_ENTRY
@ TEXT_ENTRY
area for entered text, only for Nanos
Definition nbgl_types.h:152
NB_OBJ_TYPES
@ NB_OBJ_TYPES
Definition nbgl_types.h:154
SWITCH
@ SWITCH
Switch to turn on/off something.
Definition nbgl_types.h:143
RADIO_BUTTON
@ RADIO_BUTTON
Indicator to inform whether something is on or off.
Definition nbgl_types.h:146
SPINNER
@ SPINNER
Spinner.
Definition nbgl_types.h:150
BUTTON
@ BUTTON
Rounded rectangle button with icon and/or text.
Definition nbgl_types.h:142
PROGRESS_BAR
@ PROGRESS_BAR
horizontal bar to indicate progression of something (between 0% and 100%)
Definition nbgl_types.h:145
QR_CODE
@ QR_CODE
QR Code.
Definition nbgl_types.h:147
PAGE_INDICATOR
@ PAGE_INDICATOR
horizontal bar to indicate position within pages
Definition nbgl_types.h:144
LINE
@ LINE
Vertical or Horizontal line.
Definition nbgl_types.h:140
KEYBOARD
@ KEYBOARD
Keyboard.
Definition nbgl_types.h:148
MASK_CONTROL
@ MASK_CONTROL
OS-specific object to enable/disable masked area.
Definition nbgl_types.h:153
CONTAINER
@ CONTAINER
Empty container.
Definition nbgl_types.h:138
TEXT_AREA
@ TEXT_AREA
Area to contain text line(s)
Definition nbgl_types.h:141
SCREEN
@ SCREEN
Main screen.
Definition nbgl_types.h:137
MAX
#define MAX(x, y)
Definition nbgl_types.h:103
NO_TRANSFORMATION
#define NO_TRANSFORMATION
Definition nbgl_types.h:76
NBGL_BPP_1
@ NBGL_BPP_1
1 bit per pixel
Definition nbgl_types.h:266
NBGL_BPP_2
@ NBGL_BPP_2
2 bits per pixel
Definition nbgl_types.h:267
nbgl_area_t
struct PACKED__ nbgl_area_s nbgl_area_t
Represents a rectangle area of the screen.
nbgl_refresh_mode_t
nbgl_refresh_mode_t
different modes of refresh for nbgl_refreshSpecial()
Definition nbgl_types.h:308
FULL_COLOR_CLEAN_REFRESH
@ FULL_COLOR_CLEAN_REFRESH
to be used for lock screen display (cleaner but longer refresh)
Definition nbgl_types.h:311
int16_t
signed short int16_t
Definition usbd_conf.h:50
uint16_t
unsigned short uint16_t
Definition usbd_conf.h:54
uint8_t
unsigned char uint8_t
Definition usbd_conf.h:53
Generated by doxygen 1.9.8