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);
53#ifdef HAVE_SE_TOUCH
54static void draw_button(nbgl_button_t *obj, nbgl_obj_t *prevObj, bool computePosition);
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#ifdef HAVE_SE_TOUCH
102 [LINE] = (draw_function_t) draw_line,
103 [BUTTON] = (draw_function_t) draw_button,
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#endif // HAVE_SE_TOUCH
548
549static void draw_image(nbgl_image_t *obj, nbgl_obj_t *prevObj, bool computePosition)
550{
551 const nbgl_icon_details_t *iconDetails;
552 nbgl_color_map_t colorMap;
553
554 // if buffer is NULL, let's try to call onDrawCallback, if not NULL, to get it
555 if (obj->buffer == NULL) {
556 if (obj->onDrawCallback != NULL) {
557 iconDetails = obj->onDrawCallback(obj->token);
558 }
559 else {
560 return;
561 }
562 }
563 else {
564 iconDetails = obj->buffer;
565 }
566 if (iconDetails == NULL) {
567 return;
568 }
569
570 // use dimension and bpp from the icon details
571 obj->obj.area.width = iconDetails->width;
572 obj->obj.area.height = iconDetails->height;
573 obj->obj.area.bpp = iconDetails->bpp;
574 if (computePosition) {
575 compute_position((nbgl_obj_t *) obj, prevObj);
576 }
577 LOG_DEBUG(OBJ_LOGGER, "draw_image(), x0 = %d, y0 = %d\n", obj->obj.area.x0, obj->obj.area.y0);
578 // inherit background from parent
579 obj->obj.area.backgroundColor = obj->obj.parent->area.backgroundColor;
580 if (obj->obj.area.bpp == NBGL_BPP_1) {
581 colorMap = obj->foregroundColor;
582 }
583 else if (obj->obj.area.bpp == NBGL_BPP_2) {
584 colorMap = ((WHITE << 6) | (LIGHT_GRAY << 4) | (DARK_GRAY << 2) | BLACK);
585 }
586 else {
587 colorMap = obj->foregroundColor;
588 }
589
590 nbgl_drawIcon((nbgl_area_t *) obj, obj->transformation, colorMap, iconDetails);
591}
592
593#ifdef HAVE_SE_TOUCH
594static void draw_switch(nbgl_switch_t *obj, nbgl_obj_t *prevObj, bool computePosition)
595{
596 nbgl_area_t rectArea;
597
598 // force dimensions
599 obj->obj.area.width = C_switch_60_40.width;
600 obj->obj.area.height = C_switch_60_40.height;
601 if (computePosition) {
602 compute_position((nbgl_obj_t *) obj, prevObj);
603 }
604 LOG_DEBUG(OBJ_LOGGER, "draw_switch(), x0 = %d, y0 = %d\n", obj->obj.area.x0, obj->obj.area.y0);
605
606 // inherit background from parent
607 obj->obj.area.backgroundColor = obj->obj.parent->area.backgroundColor;
608
609 rectArea.x0 = obj->obj.area.x0;
610 rectArea.y0 = obj->obj.area.y0;
611 rectArea.width = obj->obj.area.width;
612 rectArea.height = obj->obj.area.height;
613 rectArea.backgroundColor = obj->obj.area.backgroundColor;
614 rectArea.bpp = NBGL_BPP_1;
615 if (obj->state == OFF_STATE) {
616 nbgl_frontDrawImage(&rectArea, C_switch_60_40.bitmap, NO_TRANSFORMATION, obj->offColor);
617 }
618 else {
619 nbgl_frontDrawImage(&rectArea, C_switch_60_40.bitmap, VERTICAL_MIRROR, obj->onColor);
620 }
621}
622
623static void draw_radioButton(nbgl_radio_t *obj, nbgl_obj_t *prevObj, bool computePosition)
624{
625 nbgl_area_t rectArea;
626 const nbgl_icon_details_t *icon;
627 nbgl_color_map_t color_map;
628
629 // force dimensions
630 obj->obj.area.width = RADIO_WIDTH;
631 obj->obj.area.height = RADIO_HEIGHT;
632 if (computePosition) {
633 compute_position((nbgl_obj_t *) obj, prevObj);
634 }
635 LOG_DEBUG(OBJ_LOGGER,
636 "draw_radioButton(), x0 = %d, y0 = %d, state = %d\n",
637 obj->obj.area.x0,
638 obj->obj.area.y0,
639 obj->state);
640
641 // inherit background from parent
642 obj->obj.area.backgroundColor = obj->obj.parent->area.backgroundColor;
643
644 if (obj->state == OFF_STATE) {
645 icon = &RADIO_OFF_ICON;
646 color_map = obj->borderColor;
647 }
648 else {
649 icon = &RADIO_ON_ICON;
650 color_map = obj->activeColor;
651 }
652 rectArea.x0 = obj->obj.area.x0;
653 rectArea.y0 = obj->obj.area.y0;
654 rectArea.width = obj->obj.area.width;
655 rectArea.height = obj->obj.area.height;
656 rectArea.backgroundColor = obj->obj.area.backgroundColor;
657 rectArea.bpp = icon->bpp;
658 nbgl_drawIcon(&rectArea, NO_TRANSFORMATION, color_map, icon);
659}
660#endif // HAVE_SE_TOUCH
661
669static void draw_progressBar(nbgl_progress_bar_t *obj, nbgl_obj_t *prevObj, bool computePosition)
670{
671#ifdef HAVE_SE_TOUCH
672
673 uint8_t stroke = 3; // 3 pixels for border
674
675 if (computePosition) {
676 compute_position((nbgl_obj_t *) obj, prevObj);
677 }
678 LOG_DEBUG(OBJ_LOGGER,
679 "draw_progressBar(), x0 = %d, y0 = %d, level = %d %%\n",
680 obj->obj.area.x0,
681 obj->obj.area.y0,
682 obj->state);
683
684 // inherit background from parent
685 obj->obj.area.backgroundColor = obj->obj.parent->area.backgroundColor;
686
687 if (obj->partialRedraw == false) {
688 // Case of progress bar full draw
689 if (obj->withBorder) {
690 nbgl_drawRoundedBorderedRect((nbgl_area_t *) obj,
691 RADIUS_0_PIXELS,
692 stroke,
693 obj->obj.area.backgroundColor,
694 obj->foregroundColor);
695 }
696 else {
697 nbgl_drawRoundedRect(
698 (nbgl_area_t *) obj, RADIUS_0_PIXELS, obj->obj.area.backgroundColor);
699 }
700 // also reset previous width to be sure to clean up everything
701 obj->previousWidth = 0;
702 }
703 // Setup bar draw
704 nbgl_area_t barArea;
705 uint16_t barWidth = ((obj->state * obj->obj.area.width)) / 100;
706 int barDiffWith = barWidth - obj->previousWidth;
707 color_t barColor;
708 memcpy(&barArea, &obj->obj.area, sizeof(nbgl_area_t));
709
710 if (barDiffWith >= 0) {
711 // Drawing "forward"
712 barArea.x0 = obj->obj.area.x0 + obj->previousWidth;
713 barArea.width = barDiffWith;
714 barColor = obj->foregroundColor;
715 }
716 else {
717 // Drawing "backward"
718 barArea.x0 = obj->obj.area.x0 + obj->previousWidth + barDiffWith;
719 barArea.width = -barDiffWith;
720 barColor = obj->obj.area.backgroundColor;
721 }
722
723 if (barDiffWith != 0) {
724 nbgl_drawRoundedRect((nbgl_area_t *) &barArea, RADIUS_0_PIXELS, barColor);
725 }
726
727 // reset partialRedraw to be sure that in case of full redraw of the screen we redraw the
728 // full bar
729 if (obj->partialRedraw == true) {
730 obj->partialRedraw = false;
731 }
732 obj->previousWidth = barWidth;
733
734 extendRefreshArea(&barArea);
735 objRefreshAreaDone = true;
736#else // HAVE_SE_TOUCH
737 uint8_t stroke = 1; // 1 pixels for border
738 uint16_t levelWidth;
739
740 if (computePosition) {
741 compute_position((nbgl_obj_t *) obj, prevObj);
742 }
743 LOG_DEBUG(OBJ_LOGGER,
744 "draw_progressBar(), x0 = %d, y0 = %d, level = %d %%\n",
745 obj->obj.area.x0,
746 obj->obj.area.y0,
747 obj->state);
748
749 // inherit background from parent
750 obj->obj.area.backgroundColor = obj->obj.parent->area.backgroundColor;
751
752 // draw external part if necessary
753 if (obj->withBorder) {
754 nbgl_drawRoundedBorderedRect((nbgl_area_t *) obj,
755 RADIUS_3_PIXELS,
756 stroke,
757 obj->obj.area.backgroundColor,
758 obj->foregroundColor);
759 }
760 else {
761 nbgl_drawRoundedRect((nbgl_area_t *) obj, RADIUS_3_PIXELS, obj->obj.area.backgroundColor);
762 }
763 // draw level
764 levelWidth = MIN((obj->obj.area.width - 2) * obj->state / 100, (obj->obj.area.width - 2));
765 if (levelWidth > 0) {
766 nbgl_area_t rectArea;
767 rectArea.width = levelWidth;
768 rectArea.height = obj->obj.area.height - 2;
769 rectArea.backgroundColor = obj->foregroundColor;
770 rectArea.bpp = NBGL_BPP_1;
771 rectArea.x0 = obj->obj.area.x0 + 1;
772 rectArea.y0 = obj->obj.area.y0 + 1;
773
774 nbgl_frontDrawRect(&rectArea);
775 }
776#endif // HAVE_SE_TOUCH
777}
778
779#ifdef HAVE_SE_TOUCH
788static void draw_pageIndicator(nbgl_page_indicator_t *obj,
789 nbgl_obj_t *prevObj,
790 bool computePosition)
791{
792 nbgl_area_t rectArea;
793 uint16_t dashWidth;
794
795 // display nothing if less than two pages
796 if (obj->nbPages < 2) {
797 return;
798 }
799
800 if (obj->nbPages <= NB_MAX_PAGES_WITH_DASHES) {
801 int i;
802 // force height
803 obj->obj.area.height = 4;
804
805 if (computePosition) {
806 compute_position((nbgl_obj_t *) obj, prevObj);
807 }
808 LOG_DEBUG(OBJ_LOGGER,
809 "draw_pageIndicator(), x0 = %d, y0 = %d, page = %d/%d\n",
810 obj->obj.area.x0,
811 obj->obj.area.y0,
812 obj->activePage,
813 obj->nbPages);
814
815 // inherit background from parent
816 obj->obj.area.backgroundColor = obj->obj.parent->area.backgroundColor;
817
818 dashWidth = (obj->obj.area.width - ((obj->nbPages - 1) * INTER_DASHES)) / obj->nbPages;
819 rectArea.x0 = obj->obj.area.x0;
820 rectArea.y0 = obj->obj.area.y0;
821 rectArea.width = dashWidth;
822 rectArea.height = obj->obj.area.height;
823 rectArea.backgroundColor = obj->obj.area.backgroundColor;
824 rectArea.bpp = NBGL_BPP_1;
825 // draw dashes
826 for (i = 0; i < obj->activePage; i++) {
827 nbgl_frontDrawHorizontalLine(
828 &rectArea, 0xF, (obj->style == PROGRESSIVE_INDICATOR) ? BLACK : LIGHT_GRAY);
829 rectArea.x0 += dashWidth + INTER_DASHES;
830 }
831 nbgl_frontDrawHorizontalLine(&rectArea, 0xF, BLACK);
832 rectArea.x0 += dashWidth + INTER_DASHES;
833 i++;
834
835 for (; i < obj->nbPages; i++) {
836 nbgl_frontDrawHorizontalLine(&rectArea, 0xF, LIGHT_GRAY);
837 rectArea.x0 += dashWidth + INTER_DASHES;
838 }
839 }
840 else {
841 char navText[11]; // worst case is "ccc of nnn"
842
843 SPRINTF(navText, "%d of %d", obj->activePage + 1, obj->nbPages);
844 // force height
845 obj->obj.area.height = nbgl_getFontHeight(SMALL_REGULAR_FONT);
846 // the width must be at least 80
847 obj->obj.area.width = nbgl_getTextWidth(SMALL_REGULAR_FONT, navText);
848
849 if (computePosition) {
850 compute_position((nbgl_obj_t *) obj, prevObj);
851 }
852 LOG_DEBUG(OBJ_LOGGER,
853 "draw_pageIndicator(), x0 = %d, y0 = %d, page = %d/%d\n",
854 obj->obj.area.x0,
855 obj->obj.area.y0,
856 obj->activePage,
857 obj->nbPages);
858
859 // inherit background from parent
860 obj->obj.area.backgroundColor = obj->obj.parent->area.backgroundColor;
861
862 // draw active page
863 rectArea.x0 = obj->obj.area.x0;
864 rectArea.y0 = obj->obj.area.y0;
865 rectArea.width = obj->obj.area.width;
866 rectArea.height = obj->obj.area.height;
867 rectArea.backgroundColor = obj->obj.area.backgroundColor;
868 rectArea.bpp = NBGL_BPP_1;
869 nbgl_drawText(&rectArea, navText, strlen(navText), SMALL_REGULAR_FONT, DARK_GRAY);
870 }
871}
872#endif // HAVE_SE_TOUCH
873
882static void draw_textArea(nbgl_text_area_t *obj, nbgl_obj_t *prevObj, bool computePosition)
883{
884 nbgl_area_t rectArea;
885 uint16_t textWidth, fontHeight, lineHeight, textHeight, midHeight;
886 uint8_t line, nbLines;
887 const char *text;
888 nbgl_font_id_e fontId = obj->fontId;
889
890 if (computePosition) {
891 compute_position((nbgl_obj_t *) obj, prevObj);
892 }
893 // get the text of the button from the callback if not NULL
894 if (obj->onDrawCallback != NULL) {
895 obj->text = obj->onDrawCallback(obj->token);
896 }
897 text = obj->text;
898 if (text == NULL) {
899 return;
900 }
901
902 LOG_DEBUG(
903 OBJ_LOGGER,
904 "draw_textArea(), wrapping = %d, x0 = %d, y0 = %d, width = %d, height = %d, text = %s\n",
905 obj->wrapping,
906 obj->obj.area.x0,
907 obj->obj.area.y0,
908 obj->obj.area.width,
909 obj->obj.area.height,
910 text);
911
912 // inherit background from parent
913 obj->obj.area.backgroundColor = obj->obj.parent->area.backgroundColor;
914
915 // draw background to make sure it's clean
916#ifdef SCREEN_SIZE_NANO
917 if (obj->style == INVERTED_COLORS) {
918 obj->obj.area.backgroundColor = WHITE;
919 rectArea.backgroundColor = BLACK;
920 }
921 else
922#endif // SCREEN_SIZE_NANO
923 {
924 // inherit background from parent
925 obj->obj.area.backgroundColor = obj->obj.parent->area.backgroundColor;
926 rectArea.backgroundColor = obj->obj.area.backgroundColor;
927 }
928 rectArea.x0 = obj->obj.area.x0;
929 rectArea.y0 = obj->obj.area.y0;
930 rectArea.width = obj->obj.area.width;
931 rectArea.height = obj->obj.area.height;
932#ifdef SCREEN_SIZE_NANO
933 if (obj->style == INVERTED_COLORS) {
934 nbgl_drawRoundedRect(&rectArea, RADIUS_1_PIXEL, WHITE);
935 }
936 else
937#endif // SCREEN_SIZE_NANO
938 {
939 nbgl_frontDrawRect(&rectArea);
940 }
941
942 fontHeight = nbgl_getFontHeight(fontId);
943 lineHeight = nbgl_getFontLineHeight(fontId);
944 // special case of autoHideLongLine, when the text is too long for a line, draw '...' at the
945 // beginning
946 if (obj->autoHideLongLine == true) {
947#ifdef BUILD_SCREENSHOTS
948 nbgl_getTextNbLinesInWidth(fontId, text, obj->obj.area.width, obj->wrapping);
949 store_string_infos(text,
950 fontId,
951 &obj->obj.area,
952 obj->wrapping,
953 last_nb_lines,
954 last_nb_pages,
955 last_bold_state);
956#endif // BUILD_SCREENSHOTS
957 textWidth = nbgl_getSingleLineTextWidth(fontId, text);
958 if (textWidth > obj->obj.area.width) {
959 uint16_t lineWidth, lineLen;
960 uint16_t dotsWidth;
961
962 dotsWidth = nbgl_getTextWidth(fontId, "...");
963 rectArea.x0 = obj->obj.area.x0;
964 rectArea.y0 = obj->obj.area.y0 + (obj->obj.area.height - fontHeight) / 2;
965 rectArea.width = dotsWidth;
966 nbgl_drawText(&rectArea, "...", 3, fontId, obj->textColor);
967 // then draw the end of text
968 nbgl_getTextMaxLenAndWidthFromEnd(
969 fontId, text, obj->obj.area.width - dotsWidth, &lineLen, &lineWidth);
970 rectArea.x0 += dotsWidth;
971 rectArea.width = lineWidth;
972 nbgl_drawText(&rectArea,
973 &text[nbgl_getTextLength(text) - lineLen],
974 lineLen,
975 obj->fontId,
976 obj->textColor);
977 return;
978 }
979 }
980
981 // get nb lines in the given width (depending of wrapping)
982 nbLines = nbgl_getTextNbLinesInWidth(fontId, text, obj->obj.area.width, obj->wrapping);
983#ifdef BUILD_SCREENSHOTS
984 store_string_infos(
985 text, fontId, &obj->obj.area, obj->wrapping, last_nb_lines, last_nb_pages, last_bold_state);
986#endif // BUILD_SCREENSHOTS
987 // saturate nb lines if nbMaxLines is greater than 0
988 if ((obj->nbMaxLines > 0) && (obj->nbMaxLines < nbLines)) {
989 nbLines = obj->nbMaxLines;
990 }
991
992 textHeight = (nbLines - 1) * lineHeight + fontHeight;
993
994 midHeight = (obj->obj.area.height - textHeight) / 2;
995#ifdef SCREEN_SIZE_NANO
996 if (obj->style == INVERTED_COLORS) {
997 midHeight--;
998 }
999#endif // SCREEN_SIZE_NANO
1000
1001 rectArea.backgroundColor = obj->obj.area.backgroundColor;
1002 rectArea.height = fontHeight;
1003 // draw each line
1004 for (line = 0; line < nbLines; line++) {
1005 uint16_t lineWidth, lineLen;
1006
1007 nbgl_getTextMaxLenAndWidth(
1008 fontId, text, obj->obj.area.width, &lineLen, &lineWidth, obj->wrapping);
1009 if (obj->textAlignment == MID_LEFT) {
1010 rectArea.x0 = obj->obj.area.x0;
1011 }
1012 else if (obj->textAlignment == CENTER) {
1013 rectArea.x0 = obj->obj.area.x0 + (obj->obj.area.width - lineWidth) / 2;
1014 }
1015 else if (obj->textAlignment == MID_RIGHT) {
1016 rectArea.x0 = obj->obj.area.x0 + obj->obj.area.width - lineWidth;
1017 }
1018 else {
1019 LOG_FATAL(OBJ_LOGGER, "Forbidden obj->textAlignment = %d\n", obj->textAlignment);
1020 }
1021 rectArea.y0 = obj->obj.area.y0 + midHeight + line * lineHeight;
1022 rectArea.width = lineWidth;
1023
1024 LOG_DEBUG(OBJ_LOGGER,
1025 "draw_textArea(), %s line %d, lineLen %d lineWidth = %d, obj.area.height = %d, "
1026 "textHeight = %d, nbMaxLines = %d, wrapping = %d\n",
1027 text + 3,
1028 line,
1029 lineLen,
1030 lineWidth,
1031 obj->obj.area.height,
1032 textHeight,
1033 obj->nbMaxLines,
1034 obj->wrapping);
1035 if ((obj->nbMaxLines == 0) || (line < (obj->nbMaxLines - 1))) {
1036 fontId = nbgl_drawText(&rectArea, text, lineLen, fontId, obj->textColor);
1037 }
1038 else {
1039#ifdef HAVE_SE_TOUCH
1040 // for last chunk, if nbMaxLines is used, replace the 3 last chars by "..."
1041 // draw line except 3 last chars
1042 nbgl_drawText(&rectArea, text, lineLen - 3, obj->fontId, obj->textColor);
1043 // draw "..." after the other chars
1044 rectArea.x0 += nbgl_getSingleLineTextWidthInLen(obj->fontId, text, lineLen - 3);
1045 rectArea.width = nbgl_getSingleLineTextWidth(obj->fontId, "...");
1046 nbgl_drawText(&rectArea, "...", 3, obj->fontId, obj->textColor);
1047#else // HAVE_SE_TOUCH
1048 nbgl_drawText(&rectArea, text, lineLen, fontId, obj->textColor);
1049#endif // HAVE_SE_TOUCH
1050 return;
1051 }
1052 text += lineLen;
1053 /* skip trailing \n */
1054 if (*text == '\n') {
1055 text++;
1056 }
1057 }
1058}
1059
1060#ifdef NBGL_QRCODE
1069static void draw_qrCode(nbgl_qrcode_t *obj, nbgl_obj_t *prevObj, bool computePosition)
1070{
1071 nbgl_area_t rectArea;
1072
1073 if (computePosition) {
1074 compute_position((nbgl_obj_t *) obj, prevObj);
1075 }
1076 // be sure to align vertical position on multiple of 4
1077 obj->obj.area.y0 &= ~0x3;
1078 LOG_DEBUG(OBJ_LOGGER,
1079 "draw_qrCode(), x0 = %d, y0 = %d, width = %d, height = %d, text = %s\n",
1080 obj->obj.area.x0,
1081 obj->obj.area.y0,
1082 obj->obj.area.width,
1083 obj->obj.area.height,
1084 obj->text);
1085
1086 // inherit background from parent
1087 obj->obj.area.backgroundColor = obj->obj.parent->area.backgroundColor;
1088
1089 rectArea.x0 = obj->obj.area.x0;
1090 rectArea.y0 = obj->obj.area.y0;
1091 rectArea.width = obj->obj.area.width;
1092 rectArea.height = obj->obj.area.height;
1093 rectArea.backgroundColor = obj->obj.area.backgroundColor;
1094 nbgl_drawQrCode(&rectArea, obj->version, obj->text, obj->foregroundColor);
1095}
1096#endif // NBGL_QRCODE
1097
1098#ifdef NBGL_KEYBOARD
1106static void draw_keyboard(nbgl_keyboard_t *obj, nbgl_obj_t *prevObj, bool computePosition)
1107{
1108#ifndef HAVE_SE_TOUCH
1109 obj->obj.area.width = KEYBOARD_WIDTH;
1110 obj->obj.area.height = KEYBOARD_KEY_HEIGHT;
1111#endif // HAVE_SE_TOUCH
1112
1113 if (computePosition) {
1114 compute_position((nbgl_obj_t *) obj, prevObj);
1115 }
1116 LOG_DEBUG(
1117 OBJ_LOGGER, "draw_keyboard(), x0 = %d, y0 = %d\n", obj->obj.area.x0, obj->obj.area.y0);
1118
1119 // inherit background from parent
1120 obj->obj.area.backgroundColor = obj->obj.parent->area.backgroundColor;
1121
1122 nbgl_objDrawKeyboard(obj);
1123}
1124#endif // NBGL_KEYBOARD
1125
1126#ifdef NBGL_KEYPAD
1134static void draw_keypad(nbgl_keypad_t *obj, nbgl_obj_t *prevObj, bool computePosition)
1135{
1136#ifndef HAVE_SE_TOUCH
1137 obj->obj.area.height = KEYPAD_HEIGHT;
1138 obj->obj.area.width = KEYPAD_WIDTH;
1139#endif // HAVE_SE_TOUCH
1140
1141 if (computePosition) {
1142 compute_position((nbgl_obj_t *) obj, prevObj);
1143 }
1144 obj->obj.area.y0 &= ~0x3;
1145 LOG_DEBUG(OBJ_LOGGER, "draw_keypad(), x0 = %d, y0 = %d\n", obj->obj.area.x0, obj->obj.area.y0);
1146
1147 // inherit background from parent
1148 obj->obj.area.backgroundColor = obj->obj.parent->area.backgroundColor;
1149
1150 nbgl_objDrawKeypad(obj);
1151}
1152#endif // NBGL_KEYPAD
1153
1154#ifdef HAVE_SE_TOUCH
1162static void draw_spinner(nbgl_spinner_t *obj, nbgl_obj_t *prevObj, bool computePosition)
1163{
1164 nbgl_area_t rectArea;
1165 color_t foreColor;
1166
1167 obj->obj.area.width = SPINNER_WIDTH;
1168 obj->obj.area.height = SPINNER_HEIGHT;
1169
1170 if (computePosition) {
1171 compute_position((nbgl_obj_t *) obj, prevObj);
1172 }
1173 obj->obj.area.y0 &= ~0x3;
1174 LOG_DEBUG(OBJ_LOGGER, "draw_spinner(), x0 = %d, y0 = %d\n", obj->obj.area.x0, obj->obj.area.y0);
1175
1176 // inherit background from parent
1177 obj->obj.area.backgroundColor = obj->obj.parent->area.backgroundColor;
1178 // foreground color is the opposite of background one
1179 foreColor = (obj->obj.area.backgroundColor == WHITE) ? BLACK : WHITE;
1180
1181 rectArea.bpp = NBGL_BPP_1;
1182 rectArea.backgroundColor = obj->obj.area.backgroundColor;
1183 // if position is OxFF, it means "fixed" so draw 4 corners
1184 if (obj->position == 0xFF) {
1185 // draw horizontal segments
1186 rectArea.x0 = obj->obj.area.x0;
1187 rectArea.y0 = obj->obj.area.y0;
1188 rectArea.width = 20;
1189 rectArea.height = 4;
1190 nbgl_frontDrawHorizontalLine(&rectArea, 0x7, foreColor); // top left
1191 rectArea.x0 = obj->obj.area.x0 + obj->obj.area.width - rectArea.width;
1192 nbgl_frontDrawHorizontalLine(&rectArea, 0x7, foreColor); // top right
1193 rectArea.y0 = obj->obj.area.y0 + obj->obj.area.height - 4;
1194 nbgl_frontDrawHorizontalLine(&rectArea, 0xE, foreColor); // bottom right
1195 rectArea.x0 = obj->obj.area.x0;
1196 nbgl_frontDrawHorizontalLine(&rectArea, 0xE, foreColor); // bottom left
1197 // draw vertical segments
1198 rectArea.x0 = obj->obj.area.x0;
1199 rectArea.y0 = obj->obj.area.y0;
1200 rectArea.width = 3;
1201 rectArea.height = 12;
1202 rectArea.backgroundColor = foreColor;
1203 nbgl_frontDrawRect(&rectArea); // top left
1204 rectArea.x0 = obj->obj.area.x0 + obj->obj.area.width - rectArea.width;
1205 nbgl_frontDrawRect(&rectArea); // top right
1206 rectArea.y0 = obj->obj.area.y0 + obj->obj.area.height - rectArea.height;
1207 nbgl_frontDrawRect(&rectArea); // bottom right
1208 rectArea.x0 = obj->obj.area.x0;
1209 nbgl_frontDrawRect(&rectArea); // bottom left
1210 }
1211 else {
1212 uint8_t mask;
1213 // clean up full rectangle
1214 rectArea.x0 = obj->obj.area.x0;
1215 rectArea.y0 = obj->obj.area.y0;
1216 rectArea.width = obj->obj.area.width;
1217 rectArea.height = obj->obj.area.height;
1218 rectArea.backgroundColor = obj->obj.area.backgroundColor;
1219 nbgl_frontDrawRect(&rectArea); // top left
1220
1221 // draw horizontal segment in foreColor
1222 rectArea.width = 20;
1223 rectArea.height = 4;
1224 switch (obj->position) {
1225 case 0: // top left corner
1226 rectArea.x0 = obj->obj.area.x0;
1227 rectArea.y0 = obj->obj.area.y0;
1228 mask = 0x7;
1229 break;
1230 case 1: // top right
1231 rectArea.x0 = obj->obj.area.x0 + obj->obj.area.width - rectArea.width;
1232 rectArea.y0 = obj->obj.area.y0;
1233 mask = 0x7;
1234 break;
1235 case 2: // bottom right
1236 rectArea.x0 = obj->obj.area.x0 + obj->obj.area.width - rectArea.width;
1237 rectArea.y0 = obj->obj.area.y0 + obj->obj.area.height - 4;
1238 mask = 0xE;
1239 break;
1240 case 3: // bottom left
1241 rectArea.x0 = obj->obj.area.x0;
1242 rectArea.y0 = obj->obj.area.y0 + obj->obj.area.height - 4;
1243 mask = 0xE;
1244 break;
1245 default:
1246 return;
1247 }
1248 nbgl_frontDrawHorizontalLine(&rectArea, mask, foreColor);
1249
1250 // draw vertical segment in foreColor
1251 rectArea.width = 3;
1252 rectArea.height = 12;
1253 rectArea.backgroundColor = foreColor;
1254 switch (obj->position) {
1255 case 0: // top left corner
1256 rectArea.x0 = obj->obj.area.x0;
1257 rectArea.y0 = obj->obj.area.y0;
1258 break;
1259 case 1: // top right corner
1260 rectArea.x0 = obj->obj.area.x0 + obj->obj.area.width - rectArea.width;
1261 rectArea.y0 = obj->obj.area.y0;
1262 break;
1263 case 2: // bottom right corner
1264 rectArea.x0 = obj->obj.area.x0 + obj->obj.area.width - rectArea.width;
1265 rectArea.y0 = obj->obj.area.y0 + obj->obj.area.height - rectArea.height;
1266 break;
1267 case 3: // bottom left corner
1268 rectArea.x0 = obj->obj.area.x0;
1269 rectArea.y0 = obj->obj.area.y0 + obj->obj.area.height - rectArea.height;
1270 break;
1271 default:
1272 return;
1273 }
1274 nbgl_frontDrawRect(&rectArea);
1275 }
1276}
1277
1278#else // HAVE_SE_TOUCH
1279
1287static void draw_textEntry(nbgl_text_entry_t *obj, nbgl_obj_t *prevObj, bool computePosition)
1288{
1289 nbgl_area_t rectArea;
1290 int textLen = strlen(obj->text);
1291 uint32_t offsetX;
1292
1293 if (computePosition) {
1294 compute_position((nbgl_obj_t *) obj, prevObj);
1295 }
1296
1297 LOG_DEBUG(OBJ_LOGGER,
1298 "draw_textEntry(), x0 = %d, y0 = %d, width = %d, height = %d\n",
1299 obj->obj.area.x0,
1300 obj->obj.area.y0,
1301 obj->obj.area.width,
1302 obj->obj.area.height);
1303
1304 // draw background to make sure it's clean
1305 obj->obj.area.backgroundColor = WHITE;
1306 rectArea.backgroundColor = BLACK;
1307 rectArea.x0 = obj->obj.area.x0;
1308 rectArea.y0 = obj->obj.area.y0;
1309 rectArea.width = obj->obj.area.width;
1310 rectArea.height = obj->obj.area.height;
1311 rectArea.bpp = NBGL_BPP_1;
1312 nbgl_drawRoundedRect(&rectArea, RADIUS_3_PIXELS, WHITE);
1313
1314 rectArea.backgroundColor = obj->obj.area.backgroundColor;
1315 rectArea.height = nbgl_getFontHeight(obj->fontId);
1316 if (obj->nbChars > NB_MAX_LETTERS) {
1317 return;
1318 }
1319 offsetX = (obj->obj.area.width - (obj->nbChars * 10)) / 2;
1320 // draw each of the nb chars
1321 for (int i = 0; i < obj->nbChars; i++) {
1322 char digit;
1323 rectArea.x0 = obj->obj.area.x0 + offsetX + (i * 10);
1324 rectArea.y0 = obj->obj.area.y0 - 2;
1325 rectArea.width = 8;
1326 if (textLen < obj->nbChars) {
1327 if (i < textLen) {
1328 digit = obj->text[i];
1329 }
1330 else {
1331 digit = '_';
1332 }
1333 }
1334 else {
1335 // first char is '..' to notify continuing
1336 if (i == 0) {
1337 nbgl_drawText(&rectArea, "..", 2, BAGL_FONT_OPEN_SANS_EXTRABOLD_11px_1bpp, BLACK);
1338 continue;
1339 }
1340 else if (i < (obj->nbChars - 1)) {
1341 digit = obj->text[textLen - obj->nbChars + 1 + i];
1342 }
1343 else {
1344 digit = '_';
1345 }
1346 }
1347 nbgl_drawText(&rectArea, &digit, 1, BAGL_FONT_OPEN_SANS_EXTRABOLD_11px_1bpp, BLACK);
1348 }
1349}
1350#endif // HAVE_SE_TOUCH
1351
1359static void draw_image_file(nbgl_image_file_t *obj, nbgl_obj_t *prevObj, bool computePosition)
1360{
1361 if (obj->buffer == NULL) {
1362 return;
1363 }
1364 if (computePosition) {
1365 compute_position((nbgl_obj_t *) obj, prevObj);
1366 }
1367
1368 LOG_DEBUG(
1369 OBJ_LOGGER, "draw_image_file(), x0 = %d, y0 = %d\n", obj->obj.area.x0, obj->obj.area.y0);
1370 obj->obj.area.backgroundColor = WHITE;
1371 nbgl_frontDrawImageFile((nbgl_area_t *) obj, obj->buffer, BLACK, ramBuffer);
1372}
1373
1374#ifdef NBGL_MASKING
1375static void draw_mask_control(nbgl_mask_control_t *obj, nbgl_obj_t *prevObj, bool computePosition)
1376{
1377 if (computePosition) {
1378 compute_position((nbgl_obj_t *) obj, prevObj);
1379 }
1380
1381 if (obj->enableMasking) {
1382 nbgl_frontControlAreaMasking(obj->maskIndex, &obj->obj.area);
1383 }
1384 else {
1385 nbgl_frontControlAreaMasking(obj->maskIndex, NULL);
1386 }
1387}
1388#endif // NBGL_MASKING
1389
1397static void draw_object(nbgl_obj_t *obj, nbgl_obj_t *prevObj, bool computePosition)
1398{
1399 LOG_DEBUG(OBJ_LOGGER, "draw_object() obj->type = %d, prevObj = %p\n", obj->type, prevObj);
1400 objRefreshAreaDone = false;
1401 if ((obj->type < NB_OBJ_TYPES) && (draw_functions[obj->type] != NULL)) {
1402 draw_function_t func = (draw_function_t) PIC(draw_functions[obj->type]);
1403 func(obj, prevObj, computePosition);
1404 }
1405 else {
1406 LOG_DEBUG(OBJ_LOGGER, "Not existing object type\n");
1407 return;
1408 }
1409
1410#ifdef HAVE_SERIALIZED_NBGL
1411 io_seproxyhal_send_nbgl_serialized(NBGL_DRAW_OBJ, obj);
1412#endif
1413 if (!objRefreshAreaDone) {
1414 extendRefreshArea(&obj->area);
1415 }
1416}
1417
1427static void draw_obj_and_chidren(nbgl_obj_t *obj, nbgl_obj_t *prevObj, bool computePosition)
1428{
1429 uint8_t i = 0;
1430 LOG_DEBUG(OBJ_LOGGER, "draw_obj_and_chidren(): obj = %p\n", obj);
1431 // draw the object itself
1432 draw_object(obj, prevObj, computePosition);
1433
1434 if ((obj->type == SCREEN) || (obj->type == CONTAINER)) {
1435 nbgl_container_t *container = (nbgl_container_t *) obj;
1436 nbgl_obj_t *prev = NULL;
1437 LOG_DEBUG(
1438 OBJ_LOGGER, "draw_obj_and_chidren(): container->children = %p\n", container->children);
1439 // draw the children, if any
1440 if (container->children != NULL) {
1441 for (i = 0; i < container->nbChildren; i++) {
1442 nbgl_obj_t *current = container->children[i];
1443 if (current != NULL) {
1444 current->parent = (nbgl_obj_t *) container;
1445 draw_obj_and_chidren(current, prev, true);
1446 if (current->alignTo == NULL) {
1447 prev = current;
1448 }
1449 }
1450 }
1451 }
1452 }
1453}
1454
1461static void extendRefreshArea(nbgl_area_t *area)
1462{
1463 int16_t x1, y1; // bottom right corner
1464 x1 = refreshArea.x0 + refreshArea.width;
1465 y1 = refreshArea.y0 + refreshArea.height;
1466
1467 // if obj top-left is on left of current top-left corner, move top-left corner
1468 if (area->x0 < refreshArea.x0) {
1469 // No negative coordinates
1470 refreshArea.x0 = MAX(0, area->x0);
1471 }
1472 // if obj bottom-right is on right of current bottom-right corner, move bottom-right corner
1473 if (((area->x0 + area->width) > x1) || (refreshArea.width == 0)) {
1474 // Not beyond width
1475 x1 = MIN(SCREEN_WIDTH, area->x0 + area->width);
1476 }
1477 // if obj top-left is on top of current top-left corner, move top-left corner
1478 if (area->y0 < refreshArea.y0) {
1479 // No negative coordinates
1480 refreshArea.y0 = MAX(0, area->y0);
1481 }
1482 // if obj bottom-right is on bottom of current bottom-right corner, move bottom-right corner
1483 if (((area->y0 + area->height) > y1) || (refreshArea.height == 0)) {
1484 // Not beyond height
1485 y1 = MIN(SCREEN_HEIGHT, area->y0 + area->height);
1486 }
1487
1488 // sanity check
1489 if (x1 > SCREEN_WIDTH) {
1490 LOG_FATAL(OBJ_LOGGER,
1491 "extendRefreshArea: Impossible area x0 = %d width %d\n",
1492 refreshArea.x0,
1493 refreshArea.width);
1494 }
1495 if (y1 > SCREEN_HEIGHT) {
1496#ifdef HAVE_SE_TOUCH
1497 LOG_FATAL(OBJ_LOGGER,
1498 "extendRefreshArea: Impossible area y0 = %d height %d\n",
1499 refreshArea.y0,
1500 refreshArea.height);
1501#else // HAVE_SE_TOUCH
1502 y1 = SCREEN_HEIGHT;
1503#endif // HAVE_SE_TOUCH
1504 }
1505 // recompute width and height
1506 refreshArea.width = x1 - refreshArea.x0;
1507 refreshArea.height = y1 - refreshArea.y0;
1508
1509 // revaluate area bpp
1510 if (area->bpp > refreshArea.bpp) {
1511 refreshArea.bpp = area->bpp;
1512 }
1513}
1514
1520void nbgl_objDraw(nbgl_obj_t *obj)
1521{
1522 bool computePosition = false;
1523 bool fromApp;
1524
1525 LOG_DEBUG(OBJ_LOGGER, "nbgl_objDraw(): obj = %p\n", obj);
1526 // check whether it's necessary to compute position, and if this object belongs to
1527 // an Application screen
1528 if (obj->type == SCREEN) {
1529 // always compute position for screen and all sub-objects
1530 computePosition = true;
1531 fromApp = !(((nbgl_screen_t *) obj)->isUxScreen);
1532 }
1533 else {
1534 nbgl_obj_t *parent = obj;
1535 // search screen in parenthood
1536 while (parent->parent != NULL) {
1537 parent = parent->parent;
1538 }
1539 if (parent->type == SCREEN) {
1540 fromApp = !(((nbgl_screen_t *) parent)->isUxScreen);
1541 }
1542 else {
1543 // should never happen
1544 fromApp = false;
1545 }
1546 }
1547 // actually draw the object and its children, if it is allowed
1548 if (objDrawingDisabled && fromApp) {
1549 return;
1550 }
1551 draw_obj_and_chidren(obj, NULL, computePosition);
1552}
1553
1563
1569void nbgl_refreshSpecial(nbgl_refresh_mode_t mode)
1570{
1571 if ((refreshArea.width == 0) || (refreshArea.height == 0)) {
1572 return;
1573 }
1574
1575 nbgl_frontRefreshArea(&refreshArea, mode, POST_REFRESH_FORCE_POWER_OFF);
1576 LOG_DEBUG(OBJ_LOGGER,
1577 "nbgl_refreshSpecial(), x0,y0 = [%d, %d], w,h = [%d, %d]\n",
1578 refreshArea.x0,
1579 refreshArea.y0,
1580 refreshArea.width,
1581 refreshArea.height);
1582 nbgl_refreshReset();
1583}
1584
1585void nbgl_refreshSpecialWithPostRefresh(nbgl_refresh_mode_t mode, nbgl_post_refresh_t post_refresh)
1586{
1587 if ((refreshArea.width == 0) || (refreshArea.height == 0)) {
1588 return;
1589 }
1590
1591 nbgl_frontRefreshArea(&refreshArea, mode, post_refresh);
1592 LOG_DEBUG(OBJ_LOGGER,
1593 "nbgl_refreshSpecialNoPoff(), x0,y0 = [%d, %d], w,h = [%d, %d]\n",
1594 refreshArea.x0,
1595 refreshArea.y0,
1596 refreshArea.width,
1597 refreshArea.height);
1598 nbgl_refreshReset();
1599}
1600
1605bool nbgl_refreshIsNeeded(void)
1606{
1607 if ((refreshArea.width == 0) || (refreshArea.height == 0)) {
1608 return false;
1609 }
1610 return true;
1611}
1612
1617void nbgl_refreshReset(void)
1618{
1619#ifdef HAVE_SERIALIZED_NBGL
1620 io_seproxyhal_send_nbgl_serialized(NBGL_REFRESH_AREA, (nbgl_obj_t *) &refreshArea);
1621#endif
1622 refreshArea.x0 = SCREEN_WIDTH - 1;
1623 refreshArea.width = 0;
1624 refreshArea.y0 = SCREEN_HEIGHT - 1;
1625 refreshArea.height = 0;
1626 refreshArea.bpp = NBGL_BPP_2;
1627}
1628
1634void nbgl_objInit(void)
1635{
1636 // init area to the smallest size
1637 nbgl_refreshReset();
1638 objDrawingDisabled = false;
1639#ifdef HAVE_SE_TOUCH
1640 nbgl_touchInit(false);
1641#endif
1642}
1643
1649void nbgl_objAllowDrawing(bool enable)
1650{
1651 objDrawingDisabled = !enable;
1652}
1653
1659uint8_t *nbgl_objGetRAMBuffer(void)
1660{
1661 return ramBuffer;
1662}
1663
1669bool nbgl_objIsUx(nbgl_obj_t *obj)
1670{
1671 nbgl_obj_t *parent = obj;
1672 // search screen in parenthood
1673 while (parent->parent != NULL) {
1674 parent = parent->parent;
1675 }
1676 if (parent->type == SCREEN) {
1677 return (((nbgl_screen_t *) parent)->isUxScreen);
1678 }
1679 else {
1680 // should never happen
1681 return true;
1682 }
1683}
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:1520
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:1559
nbgl_refreshReset
void nbgl_refreshReset(void)
This functions resets all changes since the last refresh.
Definition nbgl_obj.c:1617
nbgl_objAllowDrawing
void nbgl_objAllowDrawing(bool enable)
This functions enables or disables drawing/refresh for all further calls.
Definition nbgl_obj.c:1649
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:1569
nbgl_objIsUx
bool nbgl_objIsUx(nbgl_obj_t *obj)
This function returns true if the object belongs to a UxScreen.
Definition nbgl_obj.c:1669
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:1585
nbgl_objGetRAMBuffer
uint8_t * nbgl_objGetRAMBuffer(void)
This function is used to get the all purpose RAM buffer.
Definition nbgl_obj.c:1659
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:1605
nbgl_objInit
void nbgl_objInit(void)
This functions inits all internal of nbgl objects layer.
Definition nbgl_obj.c:1634
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:178
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:384
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:272
color_t
color_t
Definition nbgl_types.h:120
WHITE
@ WHITE
Definition nbgl_types.h:124
DARK_GRAY
@ DARK_GRAY
Definition nbgl_types.h:122
LIGHT_GRAY
@ LIGHT_GRAY
Definition nbgl_types.h:123
BLACK
@ BLACK
Definition nbgl_types.h:121
OFF_STATE
@ OFF_STATE
Definition nbgl_types.h:180
nbgl_post_refresh_t
nbgl_post_refresh_t
Post refresh modes.
Definition nbgl_types.h:332
POST_REFRESH_FORCE_POWER_OFF
@ POST_REFRESH_FORCE_POWER_OFF
Force screen power off after refresh.
Definition nbgl_types.h:333
VERTICAL_MIRROR
#define VERTICAL_MIRROR
Definition nbgl_types.h:80
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:369
RADIUS_0_PIXELS
@ RADIUS_0_PIXELS
no radius (square angle)
Definition nbgl_types.h:355
VERTICAL
@ VERTICAL
from top to bottom
Definition nbgl_types.h:189
MIN
#define MIN(x, y)
Definition nbgl_types.h:98
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:285
TOP_MIDDLE
@ TOP_MIDDLE
Definition nbgl_types.h:162
CENTER
@ CENTER
Definition nbgl_types.h:165
BOTTOM_RIGHT
@ BOTTOM_RIGHT
Definition nbgl_types.h:169
TOP_LEFT
@ TOP_LEFT
Definition nbgl_types.h:161
NO_ALIGNMENT
@ NO_ALIGNMENT
used when parent container layout is used
Definition nbgl_types.h:160
BOTTOM_LEFT
@ BOTTOM_LEFT
Definition nbgl_types.h:167
LEFT_TOP
@ LEFT_TOP
on outside left
Definition nbgl_types.h:170
LEFT_BOTTOM
@ LEFT_BOTTOM
on outside left
Definition nbgl_types.h:171
MID_RIGHT
@ MID_RIGHT
Definition nbgl_types.h:166
RIGHT_TOP
@ RIGHT_TOP
on outside right
Definition nbgl_types.h:172
TOP_RIGHT
@ TOP_RIGHT
Definition nbgl_types.h:163
MID_LEFT
@ MID_LEFT
Definition nbgl_types.h:164
BOTTOM_MIDDLE
@ BOTTOM_MIDDLE
Definition nbgl_types.h:168
RIGHT_BOTTOM
@ RIGHT_BOTTOM
on outside right
Definition nbgl_types.h:173
KEYPAD
@ KEYPAD
Keypad.
Definition nbgl_types.h:147
IMAGE
@ IMAGE
Bitmap (y and height must be multiple of 4 on Stax)
Definition nbgl_types.h:137
IMAGE_FILE
@ IMAGE_FILE
Image file (with Ledger compression)
Definition nbgl_types.h:149
TEXT_ENTRY
@ TEXT_ENTRY
area for entered text, only for Nanos
Definition nbgl_types.h:150
NB_OBJ_TYPES
@ NB_OBJ_TYPES
Definition nbgl_types.h:152
SWITCH
@ SWITCH
Switch to turn on/off something.
Definition nbgl_types.h:141
RADIO_BUTTON
@ RADIO_BUTTON
Indicator to inform whether something is on or off.
Definition nbgl_types.h:144
SPINNER
@ SPINNER
Spinner.
Definition nbgl_types.h:148
BUTTON
@ BUTTON
Rounded rectangle button with icon and/or text.
Definition nbgl_types.h:140
PROGRESS_BAR
@ PROGRESS_BAR
horizontal bar to indicate progression of something (between 0% and 100%)
Definition nbgl_types.h:143
QR_CODE
@ QR_CODE
QR Code.
Definition nbgl_types.h:145
PAGE_INDICATOR
@ PAGE_INDICATOR
horizontal bar to indicate position within pages
Definition nbgl_types.h:142
LINE
@ LINE
Vertical or Horizontal line.
Definition nbgl_types.h:138
KEYBOARD
@ KEYBOARD
Keyboard.
Definition nbgl_types.h:146
MASK_CONTROL
@ MASK_CONTROL
OS-specific object to enable/disable masked area.
Definition nbgl_types.h:151
CONTAINER
@ CONTAINER
Empty container.
Definition nbgl_types.h:136
TEXT_AREA
@ TEXT_AREA
Area to contain text line(s)
Definition nbgl_types.h:139
SCREEN
@ SCREEN
Main screen.
Definition nbgl_types.h:135
MAX
#define MAX(x, y)
Definition nbgl_types.h:101
NO_TRANSFORMATION
#define NO_TRANSFORMATION
Definition nbgl_types.h:74
NBGL_BPP_1
@ NBGL_BPP_1
1 bit per pixel
Definition nbgl_types.h:264
NBGL_BPP_2
@ NBGL_BPP_2
2 bits per pixel
Definition nbgl_types.h:265
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:306
FULL_COLOR_CLEAN_REFRESH
@ FULL_COLOR_CLEAN_REFRESH
to be used for lock screen display (cleaner but longer refresh)
Definition nbgl_types.h:309
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