Embedded SDK
Embedded SDK
Loading...
Searching...
No Matches
nbgl_draw.c
Go to the documentation of this file.
1
8/*********************
9 * INCLUDES
10 *********************/
11#include <string.h>
12#include "nbgl_front.h"
13#include "nbgl_draw.h"
14#include "nbgl_fonts.h"
15#include "nbgl_debug.h"
16#include "nbgl_side.h"
17#ifdef NBGL_QRCODE
18#include "qrcodegen.h"
19#endif // NBGL_QRCODE
20#include "glyphs.h"
21#include "os_pic.h"
22#include "os_utils.h"
23
24/*********************
25 * DEFINES
26 *********************/
33
34#define QR_PIXEL_WIDTH_HEIGHT 4
35
36/**********************
37 * TYPEDEFS
38 **********************/
39#ifdef NBGL_QRCODE
40typedef struct {
41 uint8_t qrcode[qrcodegen_BUFFER_LEN_MAX];
42 uint8_t tempBuffer[qrcodegen_BUFFER_LEN_MAX];
43 uint8_t QrDrawBuffer[QR_PIXEL_WIDTH_HEIGHT * QR_PIXEL_WIDTH_HEIGHT * QR_MAX_PIX_SIZE / 8];
44} QrCodeBuffer_t;
45
46#define qrcode ((QrCodeBuffer_t *) ramBuffer)->qrcode
47#define tempBuffer ((QrCodeBuffer_t *) ramBuffer)->tempBuffer
48#define QrDrawBuffer ((QrCodeBuffer_t *) ramBuffer)->QrDrawBuffer
49#endif // NBGL_QRCODE
50
51/**********************
52 * STATIC PROTOTYPES
53 **********************/
54
55/**********************
56 * STATIC VARIABLES
57 **********************/
58#ifndef SCREEN_SIZE_WALLET
59static const uint8_t quarter_disc_3px_1bpp[] = {0xEC, 0xFF};
60static const uint8_t quarter_disc_3px_90_1bpp[] = {0x2F, 0xFF};
61static const uint8_t quarter_disc_3px_180_1bpp[] = {0x9B, 0xFF};
62static const uint8_t quarter_disc_3px_270_1bpp[] = {0xFA, 0x00};
63
64static const uint8_t quarter_circle_3px_1bpp[] = {0x4C, 0x00};
65static const uint8_t quarter_circle_3px_90_1bpp[] = {0x0D, 0x00};
66static const uint8_t quarter_circle_3px_180_1bpp[] = {0x19, 0x00};
67static const uint8_t quarter_circle_3px_270_1bpp[] = {0x58, 0x00};
68#endif // SCREEN_SIZE_WALLET
69
70// indexed by nbgl_radius_t (except RADIUS_0_PIXELS)
71static const uint8_t radiusValues[] = {
72#ifdef SCREEN_SIZE_WALLET
73 32,
74#ifdef TARGET_STAX
75 40,
76#else // TARGET_STAX
77 44
78#endif // TARGET_STAX
79#else // SCREEN_SIZE_WALLET
80 1,
81 3
82#endif // SCREEN_SIZE_WALLET
83};
84
85#ifdef SCREEN_SIZE_WALLET
86// indexed by nbgl_radius_t (except RADIUS_0_PIXELS)
87static const uint8_t *topQuarterDiscs[] = {
88 C_quarter_disc_top_left_32px_1bpp_bitmap,
89#ifdef TARGET_STAX
90 C_quarter_disc_top_left_40px_1bpp_bitmap,
91#else // TARGET_STAX
92 C_quarter_disc_top_left_44px_1bpp_bitmap
93#endif // TARGET_STAX
94};
95
96static const uint8_t *bottomQuarterDiscs[] = {
97 C_quarter_disc_bottom_left_32px_1bpp_bitmap,
98#ifdef TARGET_STAX
99 C_quarter_disc_bottom_left_40px_1bpp_bitmap,
100#else // TARGET_STAX
101 C_quarter_disc_bottom_left_44px_1bpp_bitmap
102#endif // TARGET_STAX
103};
104
105// indexed by nbgl_radius_t (except RADIUS_0_PIXELS)
106static const uint8_t *topQuarterCircles[] = {
107 C_quarter_circle_top_left_32px_1bpp_bitmap,
108#ifdef TARGET_STAX
109 C_quarter_circle_top_left_40px_1bpp_bitmap,
110#else // TARGET_STAX
111 C_quarter_circle_top_left_44px_1bpp_bitmap
112#endif // TARGET_STAX
113};
114
115static const uint8_t *bottomQuarterCircles[] = {
116 C_quarter_circle_bottom_left_32px_1bpp_bitmap,
117#ifdef TARGET_STAX
118 C_quarter_circle_bottom_left_40px_1bpp_bitmap,
119#else // TARGET_STAX
120 C_quarter_circle_bottom_left_44px_1bpp_bitmap
121#endif // TARGET_STAX
122};
123#endif // SCREEN_SIZE_WALLET
124
125#ifdef NBGL_QRCODE
126// ensure that the ramBuffer also used for image file decompression is big enough for QR code
127CCASSERT(qr_code_buffer, sizeof(QrCodeBuffer_t) <= GZLIB_UNCOMPRESSED_CHUNK);
128#endif // NBGL_QRCODE
129
130/**********************
131 * VARIABLES
132 **********************/
133
134/**********************
135 * STATIC PROTOTYPES
136 **********************/
137
138static void draw_circle_helper(int x_center,
139 int y_center,
140 nbgl_radius_t radiusIndex,
141 quarter_t quarter,
142 color_t borderColor,
143 color_t innerColor,
144 color_t backgroundColor)
145{
146 const uint8_t *quarter_buffer = NULL;
147 nbgl_area_t area = {.bpp = NBGL_BPP_1, .backgroundColor = backgroundColor};
148
149 // radius is not supported
150 if (radiusIndex > RADIUS_MAX) {
151 return;
152 }
153 area.width = area.height = radiusValues[radiusIndex];
154#ifdef SCREEN_SIZE_WALLET
155 if (borderColor == innerColor) {
156 if (quarter < BAGL_FILL_CIRCLE_PI_3PI2) {
157 quarter_buffer = (const uint8_t *) PIC(topQuarterDiscs[radiusIndex]);
158 }
159 else {
160 quarter_buffer = (const uint8_t *) PIC(bottomQuarterDiscs[radiusIndex]);
161 }
162 }
163 else {
164 if (quarter < BAGL_FILL_CIRCLE_PI_3PI2) {
165 quarter_buffer = (const uint8_t *) PIC(topQuarterCircles[radiusIndex]);
166 }
167 else {
168 quarter_buffer = (const uint8_t *) PIC(bottomQuarterCircles[radiusIndex]);
169 }
170 }
171 switch (quarter) {
172 case BAGL_FILL_CIRCLE_3PI2_2PI: // bottom right
173 area.x0 = x_center;
174 area.y0 = y_center;
175 nbgl_frontDrawImage(&area, quarter_buffer, VERTICAL_MIRROR, borderColor);
176 break;
177 case BAGL_FILL_CIRCLE_PI_3PI2: // bottom left
178 area.x0 = x_center - area.width;
179 area.y0 = y_center;
180 nbgl_frontDrawImage(&area, quarter_buffer, NO_TRANSFORMATION, borderColor);
181 break;
182 case BAGL_FILL_CIRCLE_0_PI2: // top right
183 area.x0 = x_center;
184 area.y0 = y_center - area.width;
185 nbgl_frontDrawImage(&area, quarter_buffer, VERTICAL_MIRROR, borderColor);
186 break;
187 case BAGL_FILL_CIRCLE_PI2_PI: // top left
188 area.x0 = x_center - area.width;
189 area.y0 = y_center - area.width;
190 nbgl_frontDrawImage(&area, quarter_buffer, NO_TRANSFORMATION, borderColor);
191 break;
192 }
193#else // SCREEN_SIZE_WALLET
194 switch (quarter) {
195 case BAGL_FILL_CIRCLE_3PI2_2PI: // bottom right
196 area.x0 = x_center;
197 area.y0 = y_center;
198 quarter_buffer = (borderColor == innerColor) ? quarter_disc_3px_180_1bpp
199 : quarter_circle_3px_180_1bpp;
200 break;
201 case BAGL_FILL_CIRCLE_PI_3PI2: // bottom left
202 area.x0 = x_center - area.width;
203 area.y0 = y_center;
204 quarter_buffer = (borderColor == innerColor) ? quarter_disc_3px_270_1bpp
205 : quarter_circle_3px_270_1bpp;
206 break;
207 case BAGL_FILL_CIRCLE_0_PI2: // top right
208 area.x0 = x_center;
209 area.y0 = y_center - area.width;
210 quarter_buffer = (borderColor == innerColor) ? quarter_disc_3px_90_1bpp
211 : quarter_circle_3px_90_1bpp;
212 break;
213 case BAGL_FILL_CIRCLE_PI2_PI: // top left
214 area.x0 = x_center - area.width;
215 area.y0 = y_center - area.width;
216 quarter_buffer
217 = (borderColor == innerColor) ? quarter_disc_3px_1bpp : quarter_circle_3px_1bpp;
218 break;
219 }
220 nbgl_frontDrawImage(&area, quarter_buffer, NO_TRANSFORMATION, borderColor);
221#endif // SCREEN_SIZE_WALLET
222}
223
224/**********************
225 * GLOBAL FUNCTIONS
226 **********************/
227
237void nbgl_drawRoundedRect(const nbgl_area_t *area, nbgl_radius_t radiusIndex, color_t innerColor)
238{
239 nbgl_area_t rectArea;
240 uint8_t radius;
241
242 LOG_DEBUG(DRAW_LOGGER,
243 "nbgl_drawRoundedRect x0 = %d, y0 = %d, width =%d, height =%d\n",
244 area->x0,
245 area->y0,
246 area->width,
247 area->height);
248
249 if (radiusIndex <= RADIUS_MAX) {
250 radius = radiusValues[radiusIndex];
251 }
252 else if (radiusIndex == RADIUS_0_PIXELS) {
253 radius = 0;
254 }
255 else {
256 // radius not supported
257 LOG_WARN(DRAW_LOGGER, "nbgl_drawRoundedRect forbidden radius index =%d\n", radiusIndex);
258 return;
259 }
260
261 // Draw main inner rectangle
262 rectArea.x0 = area->x0 + radius;
263 rectArea.y0 = area->y0;
264 rectArea.width = area->width - (2 * radius);
265 rectArea.height = area->height;
266 rectArea.backgroundColor = innerColor;
267 nbgl_frontDrawRect(&rectArea);
268 // special case when radius is null, just draw a rectangle
269 if (radiusIndex == RADIUS_0_PIXELS) {
270 return;
271 }
272 // Draw left inner rectangle
273 rectArea.x0 = area->x0;
274 rectArea.y0 = area->y0 + radius;
275 rectArea.width = radius;
276 rectArea.height = area->height - (2 * radius);
277 nbgl_frontDrawRect(&rectArea);
278 // Draw right inner rectangle
279 rectArea.x0 = area->x0 + area->width - radius;
280 rectArea.y0 = area->y0 + radius;
281 rectArea.width = radius;
282 rectArea.height = area->height - (2 * radius);
283 nbgl_frontDrawRect(&rectArea);
284
285#ifdef SCREEN_SIZE_NANO
286 if (radiusIndex == RADIUS_1_PIXEL) {
287 return;
288 }
289#endif // SCREEN_SIZE_NANO
290 // Draw 4 quarters of disc
291 draw_circle_helper(area->x0 + radius,
292 area->y0 + radius,
293 radiusIndex,
294 BAGL_FILL_CIRCLE_PI2_PI,
295 innerColor, // unused
296 innerColor,
297 area->backgroundColor);
298 draw_circle_helper(area->x0 + area->width - radius,
299 area->y0 + radius,
300 radiusIndex,
301 BAGL_FILL_CIRCLE_0_PI2,
302 innerColor, // unused
303 innerColor,
304 area->backgroundColor);
305 draw_circle_helper(area->x0 + radius,
306 area->y0 + area->height - radius,
307 radiusIndex,
308 BAGL_FILL_CIRCLE_PI_3PI2,
309 innerColor, // unused
310 innerColor,
311 area->backgroundColor);
312 draw_circle_helper(area->x0 + area->width - radius,
313 area->y0 + area->height - radius,
314 radiusIndex,
315 BAGL_FILL_CIRCLE_3PI2_2PI,
316 innerColor, // unused
317 innerColor,
318 area->backgroundColor);
319}
320
331void nbgl_drawRoundedBorderedRect(const nbgl_area_t *area,
332 nbgl_radius_t radiusIndex,
333 uint8_t stroke,
334 color_t innerColor,
335 color_t borderColor)
336{
337 uint8_t radius;
338 nbgl_area_t rectArea;
339
340 LOG_DEBUG(
341 DRAW_LOGGER,
342 "nbgl_drawRoundedBorderedRect: innerColor = %d, borderColor = %d, backgroundColor=%d\n",
343 innerColor,
344 borderColor,
345 area->backgroundColor);
346
347 if (radiusIndex <= RADIUS_MAX) {
348 radius = radiusValues[radiusIndex];
349 }
350 else if (radiusIndex == RADIUS_0_PIXELS) {
351 radius = 0;
352 }
353 else {
354 // radius not supported
355 LOG_WARN(
356 DRAW_LOGGER, "nbgl_drawRoundedBorderedRect forbidden radius index =%d\n", radiusIndex);
357 return;
358 }
359 rectArea.backgroundColor = innerColor;
360
361 // special case, when border_color == inner_color == background_color, just draw a rectangle
362 if ((innerColor == borderColor) && (borderColor == area->backgroundColor)) {
363 rectArea.x0 = area->x0;
364 rectArea.y0 = area->y0;
365 rectArea.width = area->width;
366 rectArea.height = area->height;
367 nbgl_frontDrawRect(&rectArea);
368 return;
369 }
370 // Draw 3 rectangles
371 if ((2 * radius) < area->width) {
372 rectArea.x0 = area->x0 + radius;
373 rectArea.y0 = area->y0;
374 rectArea.width = area->width - (2 * radius);
375 rectArea.height = area->height;
376 nbgl_frontDrawRect(&rectArea);
377 }
378 // special case when radius is null, left and right rectangles are not necessary
379 if (radiusIndex <= RADIUS_MAX) {
380 if ((2 * radius) < area->height) {
381 rectArea.x0 = area->x0;
382 rectArea.y0 = area->y0 + radius;
383 rectArea.width = radius;
384 rectArea.height = area->height - (2 * radius);
385 nbgl_frontDrawRect(&rectArea);
386 rectArea.x0 = area->x0 + area->width - radius;
387 rectArea.y0 = area->y0 + radius;
388 nbgl_frontDrawRect(&rectArea);
389 }
390 }
391 // border
392 // 4 rectangles (with last pixel of each corner not set)
393#ifdef SCREEN_SIZE_WALLET
394 uint8_t maskTop, maskBottom;
395 if (stroke == 1) {
396 maskTop = 0x1;
397 maskBottom = 0x8;
398 }
399 else if (stroke == 2) {
400 maskTop = 0x3;
401 maskBottom = 0xC;
402 }
403 else if (stroke == 3) {
404 maskTop = 0x7;
405 maskBottom = 0xE;
406 }
407 else if (stroke == 4) {
408 maskTop = 0xF;
409 maskBottom = 0xF;
410 }
411 else {
412 LOG_WARN(DRAW_LOGGER, "nbgl_drawRoundedBorderedRect forbidden stroke=%d\n", stroke);
413 return;
414 }
415 rectArea.x0 = area->x0 + radius;
416 rectArea.y0 = area->y0;
417 rectArea.width = area->width - 2 * radius;
418 rectArea.height = 4;
419 nbgl_frontDrawHorizontalLine(&rectArea, maskTop, borderColor); // top
420 rectArea.x0 = area->x0 + radius;
421 rectArea.y0 = area->y0 + area->height - 4;
422 nbgl_frontDrawHorizontalLine(&rectArea, maskBottom, borderColor); // bottom
423#else // SCREEN_SIZE_WALLET
424 rectArea.x0 = area->x0 + radius;
425 rectArea.y0 = area->y0;
426 rectArea.width = area->width - 2 * radius;
427 rectArea.height = stroke;
428 rectArea.backgroundColor = borderColor;
429 nbgl_frontDrawRect(&rectArea); // top
430 rectArea.y0 = area->y0 + area->height - stroke;
431 nbgl_frontDrawRect(&rectArea); // bottom
432#endif // SCREEN_SIZE_WALLET
433 if ((2 * radius) < area->height) {
434 rectArea.x0 = area->x0;
435 rectArea.y0 = area->y0 + radius;
436 rectArea.width = stroke;
437 rectArea.height = area->height - 2 * radius;
438 rectArea.backgroundColor = borderColor;
439 nbgl_frontDrawRect(&rectArea); // left
440 rectArea.x0 = area->x0 + area->width - stroke;
441 nbgl_frontDrawRect(&rectArea); // right
442 }
443
444 if (radiusIndex <= RADIUS_MAX) {
445 // Draw 4 quarters of circles
446 draw_circle_helper(area->x0 + radius,
447 area->y0 + radius,
448 radiusIndex,
449 BAGL_FILL_CIRCLE_PI2_PI,
450 borderColor,
451 innerColor,
452 area->backgroundColor);
453 draw_circle_helper(area->x0 + area->width - radius,
454 area->y0 + radius,
455 radiusIndex,
456 BAGL_FILL_CIRCLE_0_PI2,
457 borderColor,
458 innerColor,
459 area->backgroundColor);
460 draw_circle_helper(area->x0 + radius,
461 area->y0 + area->height - radius,
462 radiusIndex,
463 BAGL_FILL_CIRCLE_PI_3PI2,
464 borderColor,
465 innerColor,
466 area->backgroundColor);
467 draw_circle_helper(area->x0 + area->width - radius,
468 area->y0 + area->height - radius,
469 radiusIndex,
470 BAGL_FILL_CIRCLE_3PI2_2PI,
471 borderColor,
472 innerColor,
473 area->backgroundColor);
474 }
475}
476
489void nbgl_drawIcon(nbgl_area_t *area,
490 nbgl_transformation_t transformation,
491 nbgl_color_map_t color_map,
492 const nbgl_icon_details_t *icon)
493{
494 if (icon->isFile) {
495 nbgl_frontDrawImageFile(area, icon->bitmap, color_map, ramBuffer);
496 }
497 else {
498 nbgl_frontDrawImage(area, icon->bitmap, transformation, color_map);
499 }
500}
501
509static uint16_t get_bitmap_byte_cnt(const nbgl_font_t *font, uint8_t charId)
510{
511 if ((charId < font->first_char) || (charId > font->last_char)) {
512 return 0;
513 }
514
515 uint16_t baseId = charId - font->first_char;
516 if (charId < font->last_char) {
517 const nbgl_font_character_t *character
518 = (const nbgl_font_character_t *) PIC(&font->characters[baseId]);
519 const nbgl_font_character_t *nextCharacter
520 = (const nbgl_font_character_t *) PIC(&font->characters[baseId + 1]);
521 return (nextCharacter->bitmap_offset - character->bitmap_offset);
522 }
523 else if (charId == font->last_char) {
524 return (font->bitmap_len - font->characters[baseId].bitmap_offset);
525 }
526 return 0;
527}
528
538nbgl_font_id_e nbgl_drawText(const nbgl_area_t *area,
539 const char *text,
540 uint16_t textLen,
541 nbgl_font_id_e fontId,
542 color_t fontColor)
543{
544 // text is a series of characters, each character being a bitmap
545 // we need to align bitmaps on width multiple of 4 limitation.
546 int16_t x = area->x0;
547 nbgl_area_t rectArea;
548 const nbgl_font_t *font = nbgl_getFont(fontId);
549#ifdef HAVE_UNICODE_SUPPORT
550 nbgl_unicode_ctx_t *unicode_ctx = NULL;
551#endif // HAVE_UNICODE_SUPPORT
552
553 LOG_DEBUG(DRAW_LOGGER,
554 "nbgl_drawText: x0 = %d, y0 = %d, w = %d, h = %d, fontColor = %d, "
555 "backgroundColor=%d, text = %s\n",
556 area->x0,
557 area->y0,
558 area->width,
559 area->height,
560 fontColor,
561 area->backgroundColor,
562 text);
563
564 rectArea.backgroundColor = area->backgroundColor;
565 rectArea.bpp = (nbgl_bpp_t) font->bpp;
566
567 while (textLen > 0) {
568 const nbgl_font_character_t *character;
569 uint8_t char_width;
570 uint32_t unicode;
571 bool is_unicode;
572 const uint8_t *char_buffer;
573 int16_t char_x_min;
574 int16_t char_y_min;
575 int16_t char_x_max;
576 int16_t char_y_max;
577 uint16_t char_byte_cnt;
578 uint8_t encoding;
579 uint8_t nb_skipped_bytes;
580
581 unicode = nbgl_popUnicodeChar((const uint8_t **) &text, &textLen, &is_unicode);
582
583 if (is_unicode) {
584#ifdef HAVE_UNICODE_SUPPORT
585 if (unicode_ctx == NULL) {
586 unicode_ctx = nbgl_getUnicodeFont(fontId);
587 }
588 const nbgl_font_unicode_character_t *unicodeCharacter
589 = nbgl_getUnicodeFontCharacter(unicode);
590 // if not supported char, go to next one
591 if (unicodeCharacter == NULL) {
592 continue;
593 }
594 char_width = unicodeCharacter->width;
595#if defined(HAVE_LANGUAGE_PACK)
596 char_buffer = unicode_ctx->bitmap;
597 char_buffer += unicodeCharacter->bitmap_offset;
598
599 char_x_max = char_width;
600 char_y_max = unicode_ctx->font->height;
601
602 if (!unicode_ctx->font->crop) {
603 // Take in account the skipped bytes, if any
604 nb_skipped_bytes = (unicodeCharacter->x_min_offset & 7) << 3;
605 nb_skipped_bytes |= unicodeCharacter->y_min_offset & 7;
606 char_x_min = 0;
607 char_y_min = 0;
608 }
609 else {
610 nb_skipped_bytes = 0;
611 char_x_min = (uint16_t) unicodeCharacter->x_min_offset;
612 char_y_min = unicode_ctx->font->y_min;
613 char_y_min += (uint16_t) unicodeCharacter->y_min_offset;
614 char_x_max -= (uint16_t) unicodeCharacter->x_max_offset;
615 char_y_max -= (uint16_t) unicodeCharacter->y_max_offset;
616 }
617
618 char_byte_cnt = nbgl_getUnicodeFontCharacterByteCount();
619 encoding = unicodeCharacter->encoding;
620#endif // defined(HAVE_LANGUAGE_PACK)
621#else // HAVE_UNICODE_SUPPORT
622 continue;
623#endif // HAVE_UNICODE_SUPPORT
624 }
625 else {
626 if (unicode == '\f') {
627 break;
628 }
629 // if \b, switch fontId
630 else if (unicode == '\b') {
631 if (fontId == BAGL_FONT_OPEN_SANS_REGULAR_11px_1bpp) { // switch to bold
632 fontId = BAGL_FONT_OPEN_SANS_EXTRABOLD_11px_1bpp;
633#ifdef HAVE_UNICODE_SUPPORT
634 unicode_ctx = nbgl_getUnicodeFont(fontId);
635#endif // HAVE_UNICODE_SUPPORT
636 font = (const nbgl_font_t *) nbgl_getFont(fontId);
637 }
638 else if (fontId == BAGL_FONT_OPEN_SANS_EXTRABOLD_11px_1bpp) { // switch to regular
639 fontId = BAGL_FONT_OPEN_SANS_REGULAR_11px_1bpp;
640#ifdef HAVE_UNICODE_SUPPORT
641 unicode_ctx = nbgl_getUnicodeFont(fontId);
642#endif // HAVE_UNICODE_SUPPORT
643 font = (const nbgl_font_t *) nbgl_getFont(fontId);
644 }
645 continue;
646 }
647 // if not supported char, go to next one
648 if ((unicode < font->first_char) || (unicode > font->last_char)) {
649 continue;
650 }
651 character = (const nbgl_font_character_t *) PIC(
652 &font->characters[unicode - font->first_char]);
653 char_buffer = (const uint8_t *) PIC(&font->bitmap[character->bitmap_offset]);
654 char_width = character->width;
655 encoding = character->encoding;
656
657 char_x_max = char_width;
658 char_y_max = font->height;
659
660 if (!font->crop) {
661 // Take in account the skipped bytes, if any
662 nb_skipped_bytes = (character->x_min_offset & 7) << 3;
663 nb_skipped_bytes |= character->y_min_offset & 7;
664 char_x_min = 0;
665 char_y_min = 0;
666 }
667 else {
668 nb_skipped_bytes = 0;
669 char_x_min = (uint16_t) character->x_min_offset;
670 char_y_min = font->y_min;
671 char_y_min += (uint16_t) character->y_min_offset;
672 char_x_max -= (uint16_t) character->x_max_offset;
673 char_y_max -= (uint16_t) character->y_max_offset;
674 }
675
676 char_byte_cnt = get_bitmap_byte_cnt(font, unicode);
677 }
678
679 // Render character
680 rectArea.x0 = x + char_x_min;
681 rectArea.y0 = area->y0 + char_y_min;
682 rectArea.height = (char_y_max - char_y_min);
683 rectArea.width = (char_x_max - char_x_min);
684
685 // If char_byte_cnt = 0, call nbgl_frontDrawImageRle to let speculos notice
686 // a space character was 'displayed'
687 if (!char_byte_cnt || encoding == 1) {
688 nbgl_frontDrawImageRle(
689 &rectArea, char_buffer, char_byte_cnt, fontColor, nb_skipped_bytes);
690 }
691 else {
692 nbgl_frontDrawImage(&rectArea, char_buffer, NO_TRANSFORMATION, fontColor);
693 }
694 x += char_width - font->char_kerning;
695 }
696 return fontId;
697}
698
699#ifdef NBGL_QRCODE
700static void nbgl_frontDrawQrInternal(const nbgl_area_t *area,
701 color_t foregroundColor,
702 nbgl_qrcode_version_t version)
703{
704 int size = qrcodegen_getSize(qrcode);
705 uint16_t idx = 0;
706
707 nbgl_area_t qrArea = {.x0 = area->x0,
708 .y0 = area->y0,
709 .backgroundColor = area->backgroundColor,
710 // QR codes are 1 BPP only
711 .bpp = NBGL_BPP_1};
712 if (version == QRCODE_V4) {
713 // for each point of the V4 QR code, paint 64 pixels in image (8 in width, 8 in height)
714 qrArea.width = 2;
715 qrArea.height = QR_PIXEL_WIDTH_HEIGHT * 2 * size;
716 // paint a column of 2*size pixels in width by 8 pixels in height
717 for (int x = 0; x < size; x++) {
718 idx = 0;
719 for (int y = 0; y < size; y++) {
720 // draw 2 columns at once
721 QrDrawBuffer[idx] = qrcodegen_getModule(qrcode, x, y) ? 0xFF : 0x00;
722 QrDrawBuffer[idx + QR_V4_NB_PIX_SIZE] = QrDrawBuffer[idx];
723 idx += 1;
724 }
725 nbgl_frontDrawImage(&qrArea, QrDrawBuffer, NO_TRANSFORMATION, foregroundColor);
726 qrArea.x0 += 2;
727 nbgl_frontDrawImage(&qrArea, QrDrawBuffer, NO_TRANSFORMATION, foregroundColor);
728 qrArea.x0 += 2;
729 nbgl_frontDrawImage(&qrArea, QrDrawBuffer, NO_TRANSFORMATION, foregroundColor);
730 qrArea.x0 += 2;
731 nbgl_frontDrawImage(&qrArea, QrDrawBuffer, NO_TRANSFORMATION, foregroundColor);
732 qrArea.x0 += 2;
733 }
734 }
735 else { // V4 small or V10
736 // for each point of the V10 QR code, paint 16 pixels in image (4 in width, 4 in height)
737 qrArea.width = QR_PIXEL_WIDTH_HEIGHT * size;
738 qrArea.height = QR_PIXEL_WIDTH_HEIGHT;
739 // paint a line of 4*size pixels in width by 4 pixels in height
740 for (int y = 0; y < size; y++) {
741 idx = 0;
742 for (int x = 0; x < size; x++) {
743 memset(&QrDrawBuffer[idx], qrcodegen_getModule(qrcode, x, y) ? 0xFF : 0x00, 2);
744 idx += 2;
745 }
746 nbgl_frontDrawImage(&qrArea, QrDrawBuffer, NO_TRANSFORMATION, foregroundColor);
747 qrArea.y0 += QR_PIXEL_WIDTH_HEIGHT;
748 }
749 }
750}
751
764void nbgl_drawQrCode(const nbgl_area_t *area,
765 nbgl_qrcode_version_t version,
766 const char *text,
767 color_t foregroundColor)
768{
769 uint8_t versionNum = (version == QRCODE_V10) ? 10 : 4;
770 bool ok = qrcodegen_encodeText(text,
771 tempBuffer,
772 qrcode,
773 qrcodegen_Ecc_LOW,
774 versionNum,
775 versionNum,
776 qrcodegen_Mask_AUTO,
777 true);
778
779 if (ok) {
780 nbgl_frontDrawQrInternal(area, foregroundColor, version);
781 }
782 else {
783 LOG_WARN(
784 DRAW_LOGGER, "Impossible to draw QRCode text %s with version %d\n", text, versionNum);
785 }
786}
787#endif // NBGL_QRCODE
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
DRAW_LOGGER
@ DRAW_LOGGER
Definition nbgl_debug.h:29
QrDrawBuffer
#define QrDrawBuffer
Definition nbgl_draw.c:48
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
QR_PIXEL_WIDTH_HEIGHT
#define QR_PIXEL_WIDTH_HEIGHT
Definition nbgl_draw.c:34
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
quarter_t
quarter_t
Definition nbgl_draw.c:27
BAGL_FILL_CIRCLE_PI_3PI2
@ BAGL_FILL_CIRCLE_PI_3PI2
Definition nbgl_draw.c:30
BAGL_FILL_CIRCLE_0_PI2
@ BAGL_FILL_CIRCLE_0_PI2
Definition nbgl_draw.c:28
BAGL_FILL_CIRCLE_3PI2_2PI
@ BAGL_FILL_CIRCLE_3PI2_2PI
Definition nbgl_draw.c:31
BAGL_FILL_CIRCLE_PI2_PI
@ BAGL_FILL_CIRCLE_PI2_PI
Definition nbgl_draw.c:29
tempBuffer
#define tempBuffer
Definition nbgl_draw.c:47
qrcode
#define qrcode
Definition nbgl_draw.c:46
nbgl_drawRoundedBorderedRect
void nbgl_drawRoundedBorderedRect(const nbgl_area_t *area, nbgl_radius_t radiusIndex, 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
CCASSERT
CCASSERT(qr_code_buffer, sizeof(QrCodeBuffer_t)<=GZLIB_UNCOMPRESSED_CHUNK)
nbgl_drawQrCode
void nbgl_drawQrCode(const nbgl_area_t *area, nbgl_qrcode_version_t version, const char *text, color_t foregroundColor)
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 radiusIndex, color_t innerColor)
This functions draws a rounded corners rectangle (without border), with the given parameters.
Definition nbgl_draw.c:237
nbgl_draw.h
Middle Level API of the new BOLOS Graphical Library.
QR_MAX_PIX_SIZE
#define QR_MAX_PIX_SIZE
Definition nbgl_draw.h:25
QR_V4_NB_PIX_SIZE
#define QR_V4_NB_PIX_SIZE
Definition nbgl_draw.h:23
nbgl_fonts.h
nbgl_popUnicodeChar
uint32_t nbgl_popUnicodeChar(const uint8_t **text, uint16_t *text_length, bool *is_unicode)
Get the coming unicode value on the given UTF-8 string. If the value is a simple ASCII character,...
Definition nbgl_fonts.c:150
nbgl_font_id_e
nbgl_font_id_e
Definition nbgl_fonts.h:140
BAGL_FONT_OPEN_SANS_REGULAR_11px_1bpp
@ BAGL_FONT_OPEN_SANS_REGULAR_11px_1bpp
Definition nbgl_fonts.h:149
BAGL_FONT_OPEN_SANS_EXTRABOLD_11px_1bpp
@ BAGL_FONT_OPEN_SANS_EXTRABOLD_11px_1bpp
Definition nbgl_fonts.h:147
nbgl_getFont
const nbgl_font_t * nbgl_getFont(nbgl_font_id_e fontId)
return the non-unicode font corresponding to the given font ID
Definition nbgl_fonts.c:136
nbgl_front.h
Font screen low-Level driver API, to draw elementary forms.
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_frontDrawImageRle
void nbgl_frontDrawImageRle(const nbgl_area_t *area, const uint8_t *buffer, uint32_t buffer_len, color_t fore_color, uint8_t nb_skipped_bytes)
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)
nbgl_side.h
Side screen low-Level driver API, to draw elementary forms.
ramBuffer
uint8_t ramBuffer[]
Definition nbgl_obj.c:124
color_t
color_t
Definition nbgl_types.h:104
nbgl_transformation_t
uint8_t nbgl_transformation_t
Represents the transformation to be applied on the bitmap before rendering This is a bitfield using m...
Definition nbgl_types.h:349
VERTICAL_MIRROR
#define VERTICAL_MIRROR
Definition nbgl_types.h:64
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:356
nbgl_radius_t
nbgl_radius_t
possible radius for objects
Definition nbgl_types.h:327
RADIUS_MAX
@ RADIUS_MAX
Definition nbgl_types.h:335
RADIUS_0_PIXELS
@ RADIUS_0_PIXELS
no radius (square angle)
Definition nbgl_types.h:342
nbgl_qrcode_version_t
nbgl_qrcode_version_t
possible modes for QR Code
Definition nbgl_types.h:193
QRCODE_V10
@ QRCODE_V10
QRCode V10, can encode text len up to 1500 chars, display size = 228*228.
Definition nbgl_types.h:195
QRCODE_V4
@ QRCODE_V4
QRCode V4, can encode text len up to 62 chars, display size = 264*264.
Definition nbgl_types.h:194
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:269
NO_TRANSFORMATION
#define NO_TRANSFORMATION
Definition nbgl_types.h:58
nbgl_bpp_t
nbgl_bpp_t
Enum to represent the number of bits per pixel (BPP)
Definition nbgl_types.h:247
NBGL_BPP_1
@ NBGL_BPP_1
1 bit per pixel
Definition nbgl_types.h:248
nbgl_area_t
struct PACKED__ nbgl_area_s nbgl_area_t
Represents a rectangle area of the screen.
QrCodeBuffer_t
Definition nbgl_draw.c:40
nbgl_font_character_t
fonts nicknames to be used for various wallet size targets (non-Nano)
Definition nbgl_fonts.h:66
nbgl_font_character_t::width
uint32_t width
width of character in pixels
Definition nbgl_fonts.h:69
nbgl_font_character_t::encoding
uint32_t encoding
method used to encode bitmap data
Definition nbgl_fonts.h:68
nbgl_font_character_t::x_min_offset
uint32_t x_min_offset
x_min = x_min_offset
Definition nbgl_fonts.h:70
nbgl_font_character_t::bitmap_offset
uint32_t bitmap_offset
offset of this character in chars buffer
Definition nbgl_fonts.h:67
nbgl_font_character_t::y_min_offset
uint32_t y_min_offset
y_min = (y_min + y_min_offset)
Definition nbgl_fonts.h:71
nbgl_font_character_t::x_max_offset
uint32_t x_max_offset
x_max = width - x_max_offset
Definition nbgl_fonts.h:72
nbgl_font_character_t::y_max_offset
uint32_t y_max_offset
y_max = (height - y_max_offset)
Definition nbgl_fonts.h:73
nbgl_font_t
structure defining an ASCII font
Definition nbgl_fonts.h:80
nbgl_font_t::char_kerning
uint8_t char_kerning
kerning for the font
Definition nbgl_fonts.h:86
nbgl_font_t::crop
uint8_t crop
If false, x_min_offset+y_min_offset=bytes to skip.
Definition nbgl_fonts.h:87
nbgl_font_t::first_char
uint8_t first_char
ASCII code of the first character in bitmap and in characters fields.
Definition nbgl_fonts.h:90
nbgl_font_t::bitmap_len
uint32_t bitmap_len
Size in bytes of the associated bitmap.
Definition nbgl_fonts.h:81
nbgl_font_t::bitmap
uint8_t const * bitmap
array containing bitmaps of all characters
Definition nbgl_fonts.h:95
nbgl_font_t::characters
const nbgl_font_character_t *const characters
array containing definitions of all characters
Definition nbgl_fonts.h:94
nbgl_font_t::height
uint8_t height
height of all characters in pixels
Definition nbgl_fonts.h:84
nbgl_font_t::last_char
uint8_t last_char
ASCII code of the last character in bitmap and in characters fields.
Definition nbgl_fonts.h:92
nbgl_font_t::y_min
uint8_t y_min
Most top Y coordinate of any char in the font.
Definition nbgl_fonts.h:88
nbgl_font_t::bpp
uint8_t bpp
number of bits per pixels
Definition nbgl_fonts.h:83
nbgl_font_unicode_character_t
structure defining a unicode character (except the bitmap)
Definition nbgl_fonts.h:108
nbgl_font_unicode_character_t::encoding
uint32_t encoding
method used to encode bitmap data
Definition nbgl_fonts.h:110
nbgl_font_unicode_character_t::width
uint32_t width
width of character in pixels
Definition nbgl_fonts.h:111
nbgl_font_unicode_character_t::x_min_offset
uint32_t x_min_offset
x_min = x_min_offset
Definition nbgl_fonts.h:112
nbgl_font_unicode_character_t::y_min_offset
uint32_t y_min_offset
y_min = (y_min + y_min_offset)
Definition nbgl_fonts.h:113
nbgl_font_unicode_character_t::y_max_offset
uint32_t y_max_offset
y_max = (height - y_max_offset)
Definition nbgl_fonts.h:115
nbgl_font_unicode_character_t::x_max_offset
uint32_t x_max_offset
x_max = width - x_max_offset
Definition nbgl_fonts.h:114
nbgl_font_unicode_character_t::bitmap_offset
uint32_t bitmap_offset
offset of this character in chars buffer
Definition nbgl_fonts.h:116
nbgl_font_unicode_t::crop
uint8_t crop
If false, x_min_offset+y_min_offset=bytes to skip.
Definition nbgl_fonts.h:129
nbgl_font_unicode_t::y_min
uint8_t y_min
Most top Y coordinate of any char in the font.
Definition nbgl_fonts.h:130
nbgl_font_unicode_t::height
uint8_t height
height of all characters in pixels
Definition nbgl_fonts.h:126
nbgl_unicode_ctx_s
Definition nbgl_fonts.h:159
nbgl_unicode_ctx_s::font
const nbgl_font_unicode_t * font
Definition nbgl_fonts.h:160
nbgl_unicode_ctx_s::bitmap
const uint8_t * bitmap
Definition nbgl_fonts.h:162
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