ledger-secure-sdk/wallet/nbgl__layout__nanos_8c_source.html

#ifndef HAVE_SE_TOUCH

/*********************

 *      INCLUDES

 *********************/

#include <string.h>

#include <stdlib.h>

#include "nbgl_debug.h"

#include "nbgl_front.h"

#include "nbgl_layout_internal_nanos.h"

#include "nbgl_obj.h"

#include "nbgl_draw.h"

#include "nbgl_screen.h"

#include "nbgl_touch.h"

#include "glyphs.h"

#include "os_pic.h"

#include "os_helpers.h"

#include "lcx_rng.h"


/*********************

 *      DEFINES

 *********************/


#define NB_MAX_LAYOUTS 3


// used by screen

#define NB_MAX_SCREEN_CHILDREN 7


#define BUTTON_MARGIN_Y 12


// this is the maximum number of chars fitting in a line

#define NB_MAX_CHAR_IN_LINE 20


#define ELLIPSIS      "..."

#define ELLIPSIS_SIZE sizeof(ELLIPSIS)  // includes '\0'


/**********************

 *      MACROS

 **********************/


/**********************

 *      TYPEDEFS

 **********************/


/**********************

 *      VARIABLES

 **********************/


static nbgl_layoutInternal_t gLayout[NB_MAX_LAYOUTS] = {0};


/**********************

 *  STATIC PROTOTYPES

 **********************/


static void buttonCallback(nbgl_screen_t *screen, nbgl_buttonEvent_t buttonEvent)

{

    uint8_t                i      = NB_MAX_LAYOUTS;

    nbgl_layoutInternal_t *layout = NULL;


    // parse all layouts (starting with modals) to find the object

    while (i > 0) {

        i--;

        if ((screen->index == gLayout[i].layer) && (gLayout[i].nbChildren > 0)) {

            // found

            layout = &gLayout[i];

            break;

        }

    }

    if (layout == NULL) {

        LOG_WARN(

            LAYOUT_LOGGER,

            "touchCallback(): screen->index = %d, buttonEvent = %d, no matching active layout\n",

            screen->index,

            buttonEvent);

        return;

    }


#ifdef NBGL_KEYPAD

    // special case of keypad

    nbgl_obj_t *kpd = nbgl_screenContainsObjType(screen, KEYPAD);

    if (kpd) {

        nbgl_keypadCallback(kpd, buttonEvent);

        return;

    }

    else

#endif  // NBGL_KEYPAD

#ifdef NBGL_KEYBOARD

    {

        nbgl_obj_t *kbd = nbgl_screenContainsObjType(screen, KEYBOARD);

        if (kbd) {

            nbgl_keyboardCallback(kbd, buttonEvent);

            return;

        }

    }

#endif  // NBGL_KEYBOARD

    if (layout->callback != NULL) {

        layout->callback((nbgl_layout_t *) layout, buttonEvent);

    }

}


/**********************

 *   GLOBAL FUNCTIONS

 **********************/


void layoutAddObject(nbgl_layoutInternal_t *layout, nbgl_obj_t *obj)

{

    if (layout->nbChildren == NB_MAX_SCREEN_CHILDREN) {

        LOG_FATAL(LAYOUT_LOGGER, "layoutAddObject(): No more object\n");

    }

    layout->children[layout->nbChildren] = obj;

    layout->nbChildren++;

}


nbgl_layout_t *nbgl_layoutGet(const nbgl_layoutDescription_t *description)

{

    nbgl_layoutInternal_t *layout = NULL;


    // find an empty layout in the proper "layer"

    if (description->modal) {

        if (gLayout[1].nbChildren == 0) {

            layout = &gLayout[1];

        }

        else if (gLayout[2].nbChildren == 0) {

            layout = &gLayout[2];

        }

    }

    else {

        // automatically "release" a potentially opened non-modal layout

        gLayout[0].nbChildren = 0;

        layout                = &gLayout[0];

    }

    if (layout == NULL) {

        LOG_WARN(LAYOUT_LOGGER, "nbgl_layoutGet(): impossible to get a layout!\n");

        return NULL;

    }


    // reset globals

    memset(layout, 0, sizeof(nbgl_layoutInternal_t));


    layout->callback = (nbgl_layoutButtonCallback_t) PIC(description->onActionCallback);

    layout->modal    = description->modal;

    if (description->modal) {

        layout->layer = nbgl_screenPush(&layout->children,

                                        NB_MAX_SCREEN_CHILDREN,

                                        &description->ticker,

                                        (nbgl_buttonCallback_t) buttonCallback);

    }

    else {

        nbgl_screenSet(&layout->children,

                       NB_MAX_SCREEN_CHILDREN,

                       &description->ticker,

                       (nbgl_buttonCallback_t) buttonCallback);

        layout->layer = 0;

    }


    return (nbgl_layout_t *) layout;

}


int nbgl_layoutAddNavigation(nbgl_layout_t *layout, nbgl_layoutNavigation_t *info)

{

    nbgl_layoutInternal_t *layoutInt = (nbgl_layoutInternal_t *) layout;


    LOG_DEBUG(LAYOUT_LOGGER, "nbgl_layoutAddNavigation():\n");

    if (layout == NULL) {

        return -1;

    }


    nbgl_image_t *image;

    if (info->indication & LEFT_ARROW) {

        image                  = (nbgl_image_t *) nbgl_objPoolGet(IMAGE, layoutInt->layer);

        image->foregroundColor = WHITE;

        image->buffer          = (info->direction == HORIZONTAL_NAV) ? &C_icon_left : &C_icon_up;

        image->obj.area.bpp    = NBGL_BPP_1;

        image->obj.alignment   = MID_LEFT;

        layoutAddObject(layoutInt, (nbgl_obj_t *) image);

    }

    if (info->indication & RIGHT_ARROW) {

        image                  = (nbgl_image_t *) nbgl_objPoolGet(IMAGE, layoutInt->layer);

        image->foregroundColor = WHITE;

        image->buffer          = (info->direction == HORIZONTAL_NAV) ? &C_icon_right : &C_icon_down;

        image->obj.area.bpp    = NBGL_BPP_1;

        image->obj.alignment   = MID_RIGHT;

        layoutAddObject(layoutInt, (nbgl_obj_t *) image);

    }

    return 0;

}


int nbgl_layoutAddText(nbgl_layout_t                  *layout,

                       const char                     *text,

                       const char                     *subText,

                       nbgl_contentCenteredInfoStyle_t style)

{

    nbgl_layoutInternal_t *layoutInt = (nbgl_layoutInternal_t *) layout;

    nbgl_container_t      *container;

    nbgl_text_area_t      *textArea;

    uint16_t               fullHeight = 0;


    LOG_DEBUG(LAYOUT_LOGGER, "nbgl_layoutAddText():\n");

    if (layout == NULL) {

        return -1;

    }

    container = (nbgl_container_t *) nbgl_objPoolGet(CONTAINER, layoutInt->layer);


    // get container children

    container->nbChildren = 1;

    if (subText != NULL) {

        container->nbChildren += 2;  // possibly 2 buttons

    }


    container->children       = nbgl_containerPoolGet(container->nbChildren, layoutInt->layer);

    container->obj.area.width = AVAILABLE_WIDTH;


    textArea                 = (nbgl_text_area_t *) nbgl_objPoolGet(TEXT_AREA, layoutInt->layer);

    textArea->textColor      = WHITE;

    textArea->text           = PIC(text);

    textArea->textAlignment  = CENTER;

    textArea->fontId         = (style == REGULAR_INFO) ? BAGL_FONT_OPEN_SANS_REGULAR_11px_1bpp

                                                       : BAGL_FONT_OPEN_SANS_EXTRABOLD_11px_1bpp;

    textArea->obj.area.width = AVAILABLE_WIDTH;


    uint16_t nbLines

        = nbgl_getTextNbLinesInWidth(textArea->fontId, textArea->text, AVAILABLE_WIDTH, true);

    // if more than available lines on screen

    if (nbLines > NB_MAX_LINES) {

        uint16_t len;


        nbLines              = NB_MAX_LINES;

        textArea->nbMaxLines = NB_MAX_LINES;

        nbgl_getTextMaxLenInNbLines(

            textArea->fontId, textArea->text, AVAILABLE_WIDTH, nbLines, &len, true);

        textArea->len = len;

    }

    const nbgl_font_t *font   = nbgl_getFont(textArea->fontId);

    textArea->obj.area.height = nbLines * font->line_height;

    textArea->wrapping        = true;

    textArea->obj.alignment   = TOP_MIDDLE;

    fullHeight += textArea->obj.area.height;

    container->children[0] = (nbgl_obj_t *) textArea;


    if (subText != NULL) {

        if (style != BUTTON_INFO) {

            textArea            = (nbgl_text_area_t *) nbgl_objPoolGet(TEXT_AREA, layoutInt->layer);

            textArea->textColor = WHITE;

            textArea->text      = PIC(subText);

            textArea->wrapping  = true;

            textArea->fontId    = BAGL_FONT_OPEN_SANS_REGULAR_11px_1bpp;

            textArea->obj.area.width = AVAILABLE_WIDTH;

            nbLines                  = nbgl_getTextNbLinesInWidth(

                textArea->fontId, textArea->text, AVAILABLE_WIDTH, true);

            // if more than available lines on screen

            if (nbLines > (NB_MAX_LINES - 1)) {

                uint16_t len;

                nbLines              = NB_MAX_LINES - 1;

                textArea->nbMaxLines = nbLines;

                nbgl_getTextMaxLenInNbLines(

                    textArea->fontId, textArea->text, AVAILABLE_WIDTH, nbLines, &len, true);

                textArea->len = len;

            }

            if (style == REGULAR_INFO) {

                textArea->obj.area.height = nbLines * font->line_height;

            }

            else {

                // the sub text must be vertically centered in a 3 lines container

                textArea->obj.area.height = 3 * font->line_height;

            }

            textArea->textAlignment        = CENTER;

            textArea->obj.alignment        = NO_ALIGNMENT;

            textArea->obj.alignmentMarginY = 2;

            fullHeight += textArea->obj.area.height + textArea->obj.alignmentMarginY;

            container->children[1] = (nbgl_obj_t *) textArea;

        }

        else {

            nbgl_button_t *button = (nbgl_button_t *) nbgl_objPoolGet(BUTTON, layoutInt->layer);

            uint16_t       textWidth;

            uint16_t       len   = 0;

            uint16_t       width = 0;


            button->foregroundColor = BLACK;

            button->innerColor      = WHITE;

            button->borderColor     = WHITE;

            button->radius          = RADIUS_3_PIXELS;

            button->text            = (const char *) PIC(subText);

            button->fontId          = BAGL_FONT_OPEN_SANS_EXTRABOLD_11px_1bpp;

            button->obj.area.height = 14;

            button->obj.alignment   = CENTER;


            textWidth = nbgl_getTextWidth(button->fontId, button->text);

            if ((textWidth + BUTTON_MARGIN_Y) >= AVAILABLE_WIDTH) {

                static char tmpString[NB_MAX_CHAR_IN_LINE];

                nbgl_getTextMaxLenAndWidth(button->fontId,

                                           button->text,

                                           AVAILABLE_WIDTH - BUTTON_MARGIN_Y,

                                           &len,

                                           &width,

                                           true);

                button->obj.area.width = width + BUTTON_MARGIN_Y;

                // copy the first 'len' chars in the tmp string buffer (max is

                // NB_MAX_CHAR_IN_LINE-1)

                memcpy(tmpString, button->text, MIN(len, (NB_MAX_CHAR_IN_LINE - 1)));

                // NULL termination

                tmpString[MIN(len, (NB_MAX_CHAR_IN_LINE - 1))] = '\0';

                button->text                                   = PIC(tmpString);

                button->obj.alignmentMarginY                   = 8 - 7;

            }

            else {

                button->obj.area.width       = textWidth + BUTTON_MARGIN_Y;

                button->obj.alignmentMarginY = 8;

            }

            container->children[1] = (nbgl_obj_t *) button;


            // if too long text, draw a second button under the first one, with the remaining text

            if (width > 0) {

                button = (nbgl_button_t *) nbgl_objPoolGet(BUTTON, layoutInt->layer);

                button->foregroundColor      = BLACK;

                button->innerColor           = WHITE;

                button->borderColor          = WHITE;

                button->radius               = RADIUS_3_PIXELS;

                button->text                 = (const char *) PIC(subText) + len;

                button->fontId               = BAGL_FONT_OPEN_SANS_EXTRABOLD_11px_1bpp;

                button->obj.area.height      = 14;

                button->obj.alignment        = CENTER;

                button->obj.alignmentMarginY = 8 + 7;

                textWidth                    = nbgl_getTextWidth(button->fontId, button->text);

                if ((textWidth + BUTTON_MARGIN_Y) >= AVAILABLE_WIDTH) {

                    static char    tmpString2[NB_MAX_CHAR_IN_LINE];

                    const uint16_t ellipsisWidth = nbgl_getTextWidth(button->fontId, ELLIPSIS);

                    nbgl_getTextMaxLenAndWidth(button->fontId,

                                               button->text,

                                               AVAILABLE_WIDTH - BUTTON_MARGIN_Y - ellipsisWidth,

                                               &len,

                                               &width,

                                               true);

                    button->obj.area.width = width + ellipsisWidth + BUTTON_MARGIN_Y;

                    // copy the first 'len' chars then append ELLIPSIS (ELLIPSIS_SIZE includes '\0')

                    uint16_t copyLen = MIN(len, (NB_MAX_CHAR_IN_LINE - ELLIPSIS_SIZE));

                    memcpy(tmpString2, button->text, copyLen);

                    memcpy(tmpString2 + copyLen, ELLIPSIS, ELLIPSIS_SIZE);

                    button->text = PIC(tmpString2);

                }

                else {

                    button->obj.area.width = textWidth + BUTTON_MARGIN_Y;

                }

                container->children[2] = (nbgl_obj_t *) button;

            }


            fullHeight += 44;

        }

    }

    container->obj.area.height = fullHeight;

    container->layout          = VERTICAL;

    container->obj.alignment   = CENTER;

    // set this new obj as child of main container

    layoutAddObject(layoutInt, (nbgl_obj_t *) container);


    return 0;

}


int nbgl_layoutAddMenuList(nbgl_layout_t *layout, nbgl_layoutMenuList_t *list)

{

    nbgl_layoutInternal_t *layoutInt = (nbgl_layoutInternal_t *) layout;

    uint8_t                i;


    LOG_DEBUG(LAYOUT_LOGGER, "nbgl_layoutAddMenuList():\n");

    if (layout == NULL) {

        return -1;

    }

    for (i = 0; i < list->nbChoices; i++) {

        nbgl_text_area_t *textArea;


        // check whether this object is visible or not

        // only the two objects above or below the selected one are visible

        if (((list->selectedChoice > 2) && (i < (list->selectedChoice - 2)))

            || (i > (list->selectedChoice + 2))) {

            continue;

        }


        textArea = (nbgl_text_area_t *) nbgl_objPoolGet(TEXT_AREA, layoutInt->layer);


        // init text area for this choice

        textArea->text                 = list->callback(i);

        textArea->textAlignment        = CENTER;

        textArea->obj.area.width       = AVAILABLE_WIDTH;

        textArea->obj.area.height      = 16;

        textArea->style                = NO_STYLE;

        textArea->obj.alignment        = CENTER;

        textArea->obj.alignmentMarginY = ((i - list->selectedChoice) * 16);

        textArea->textColor            = WHITE;


        // highlight init choice

        if (i == list->selectedChoice) {

            textArea->fontId = BAGL_FONT_OPEN_SANS_EXTRABOLD_11px_1bpp;

        }

        else {

            textArea->fontId = BAGL_FONT_OPEN_SANS_REGULAR_11px_1bpp;

        }


        // set this new obj as child of main container

        layoutAddObject(layoutInt, (nbgl_obj_t *) textArea);

    }


    return 0;

}


int nbgl_layoutAddCenteredInfo(nbgl_layout_t *layout, const nbgl_layoutCenteredInfo_t *info)

{

    nbgl_layoutInternal_t *layoutInt = (nbgl_layoutInternal_t *) layout;

    nbgl_container_t      *container;

    nbgl_text_area_t      *textArea   = NULL;

    nbgl_image_t          *image      = NULL;

    uint16_t               fullHeight = 0;


    LOG_DEBUG(LAYOUT_LOGGER, "nbgl_layoutAddCenteredInfo():\n");

    if (layout == NULL) {

        return -1;

    }


    container = (nbgl_container_t *) nbgl_objPoolGet(CONTAINER, layoutInt->layer);


    // 3 children at max

    container->children   = nbgl_containerPoolGet(3, layoutInt->layer);

    container->nbChildren = 0;

    if (info->icon != NULL) {

        image                  = (nbgl_image_t *) nbgl_objPoolGet(IMAGE, layoutInt->layer);

        image->foregroundColor = WHITE;

        image->buffer          = PIC(info->icon);

        image->obj.area.bpp    = NBGL_BPP_1;

        image->obj.alignment   = TOP_MIDDLE;

        image->obj.alignTo     = NULL;


        fullHeight += image->buffer->height;

        container->children[container->nbChildren] = (nbgl_obj_t *) image;

        container->nbChildren++;

    }

    if (info->text1 != NULL) {

        textArea                = (nbgl_text_area_t *) nbgl_objPoolGet(TEXT_AREA, layoutInt->layer);

        textArea->textColor     = WHITE;

        textArea->text          = PIC(info->text1);

        textArea->textAlignment = CENTER;

        textArea->fontId = (info->style == REGULAR_INFO) ? BAGL_FONT_OPEN_SANS_REGULAR_11px_1bpp

                                                         : BAGL_FONT_OPEN_SANS_EXTRABOLD_11px_1bpp;

        textArea->obj.area.width = AVAILABLE_WIDTH;

        textArea->wrapping       = true;

        uint16_t nbLines

            = nbgl_getTextNbLinesInWidth(textArea->fontId, textArea->text, AVAILABLE_WIDTH, true);

        // if more than available lines on screen

        if (nbLines > NB_MAX_LINES) {

            uint16_t len;

            nbLines              = NB_MAX_LINES;

            textArea->nbMaxLines = NB_MAX_LINES;

            nbgl_getTextMaxLenInNbLines(

                textArea->fontId, textArea->text, AVAILABLE_WIDTH, nbLines, &len, true);

            textArea->len = len;

        }

        const nbgl_font_t *font   = nbgl_getFont(textArea->fontId);

        textArea->obj.area.height = nbLines * font->line_height;

        textArea->style           = NO_STYLE;

        if (info->icon != NULL) {

            textArea->obj.alignment = BOTTOM_MIDDLE;  // under icon

            textArea->obj.alignTo   = (nbgl_obj_t *) container->children[container->nbChildren - 1];

            textArea->obj.alignmentMarginY = (nbLines < 3) ? 4 : 0;

        }

        else if (info->text2 == NULL) {

            textArea->obj.alignment = CENTER;

            textArea->obj.alignTo   = NULL;

        }

        else {

            textArea->obj.alignment = TOP_MIDDLE;

            textArea->obj.alignTo   = NULL;

        }


        fullHeight += textArea->obj.area.height + textArea->obj.alignmentMarginY;


        container->children[container->nbChildren] = (nbgl_obj_t *) textArea;

        container->nbChildren++;

    }

    if (info->text2 != NULL) {

        textArea                = (nbgl_text_area_t *) nbgl_objPoolGet(TEXT_AREA, layoutInt->layer);

        textArea->textColor     = WHITE;

        textArea->text          = PIC(info->text2);

        textArea->textAlignment = CENTER;

        textArea->fontId        = BAGL_FONT_OPEN_SANS_REGULAR_11px_1bpp;

        textArea->obj.area.width = AVAILABLE_WIDTH;

        textArea->wrapping       = true;

        uint16_t nbLines

            = nbgl_getTextNbLinesInWidth(textArea->fontId, textArea->text, AVAILABLE_WIDTH, true);

        // if more than available lines on screen

        if (nbLines > (NB_MAX_LINES - 1)) {

            uint16_t len;

            nbLines              = NB_MAX_LINES - 1;

            textArea->nbMaxLines = nbLines;

            nbgl_getTextMaxLenInNbLines(

                textArea->fontId, textArea->text, AVAILABLE_WIDTH, nbLines, &len, true);

            textArea->len = len;

        }

        const nbgl_font_t *font   = nbgl_getFont(textArea->fontId);

        textArea->obj.area.height = nbLines * font->line_height;


        textArea->style         = NO_STYLE;

        textArea->obj.alignment = BOTTOM_MIDDLE;

        textArea->obj.alignTo   = (nbgl_obj_t *) container->children[container->nbChildren - 1];

        textArea->obj.alignmentMarginY = 2;


        fullHeight += textArea->obj.area.height + textArea->obj.alignmentMarginY;


        container->children[container->nbChildren] = (nbgl_obj_t *) textArea;

        container->nbChildren++;

    }

    container->obj.area.height      = fullHeight;

    container->layout               = VERTICAL;

    container->obj.alignmentMarginY = 0;

    if (info->onTop) {

        container->obj.alignment = TOP_MIDDLE;

    }

    else {

        container->obj.alignment = CENTER;

    }


    container->obj.area.width = AVAILABLE_WIDTH;


    // set this new container as child of main container

    layoutAddObject(layoutInt, (nbgl_obj_t *) container);


    return 0;

}


int nbgl_layoutAddProgressBar(nbgl_layout_t *layout, const nbgl_layoutProgressBar_t *barLayout)

{

    nbgl_layoutInternal_t *layoutInt = (nbgl_layoutInternal_t *) layout;

    nbgl_progress_bar_t   *progress;


    LOG_DEBUG(LAYOUT_LOGGER, "nbgl_layoutAddProgressBar():\n");

    if (layout == NULL) {

        return -1;

    }

    if (barLayout->text != NULL) {

        nbgl_text_area_t *textArea;


        textArea                       = (nbgl_text_area_t *) nbgl_objPoolGet(TEXT_AREA,

                                                        ((nbgl_layoutInternal_t *) layout)->layer);

        textArea->textColor            = WHITE;

        textArea->text                 = PIC(barLayout->text);

        textArea->textAlignment        = CENTER;

        textArea->fontId               = BAGL_FONT_OPEN_SANS_REGULAR_11px_1bpp;

        textArea->obj.area.width       = AVAILABLE_WIDTH;

        textArea->obj.area.height      = nbgl_getTextHeight(textArea->fontId, textArea->text);

        textArea->obj.alignment        = TOP_MIDDLE;

        textArea->obj.alignmentMarginX = 0;

        textArea->obj.alignmentMarginY = 16;  // 16 px from top

        layoutAddObject(layoutInt, (nbgl_obj_t *) textArea);

    }

    progress                       = (nbgl_progress_bar_t *) nbgl_objPoolGet(PROGRESS_BAR,

                                                       ((nbgl_layoutInternal_t *) layout)->layer);

    progress->foregroundColor      = WHITE;

    progress->withBorder           = true;

    progress->state                = barLayout->percentage;

    progress->obj.area.width       = 102;

    progress->obj.area.height      = 14;

    progress->obj.alignment        = TOP_MIDDLE;

    progress->obj.alignmentMarginX = 0;

    progress->obj.alignmentMarginY = 33;  // 33px from top

    layoutAddObject(layoutInt, (nbgl_obj_t *) progress);


    if (barLayout->subText != NULL) {

        nbgl_text_area_t *subTextArea;


        subTextArea = (nbgl_text_area_t *) nbgl_objPoolGet(

            TEXT_AREA, ((nbgl_layoutInternal_t *) layout)->layer);

        subTextArea->textColor       = WHITE;

        subTextArea->text            = PIC(barLayout->subText);

        subTextArea->textAlignment   = CENTER;

        subTextArea->fontId          = BAGL_FONT_OPEN_SANS_REGULAR_11px_1bpp;

        subTextArea->obj.area.width  = AVAILABLE_WIDTH;

        subTextArea->obj.area.height = nbgl_getTextHeight(subTextArea->fontId, subTextArea->text);

        subTextArea->obj.alignment   = BOTTOM_MIDDLE;

        subTextArea->obj.alignTo     = (nbgl_obj_t *) progress;

        subTextArea->obj.alignmentMarginX = 0;

        subTextArea->obj.alignmentMarginY = 4;

        layoutAddObject(layoutInt, (nbgl_obj_t *) subTextArea);

    }


    return 0;

}


int nbgl_layoutAddButton(nbgl_layout_t *layout, const nbgl_layoutButton_t *buttonInfo)

{

    nbgl_layoutInternal_t *layoutInt = (nbgl_layoutInternal_t *) layout;

    nbgl_button_t         *button;


    LOG_DEBUG(LAYOUT_LOGGER, "nbgl_layoutAddButton():\n");

    if (layout == NULL) {

        return -1;

    }

    button = (nbgl_button_t *) nbgl_objPoolGet(BUTTON, ((nbgl_layoutInternal_t *) layout)->layer);

    button->foregroundColor = BLACK;

    button->innerColor      = WHITE;

    button->borderColor     = WHITE;

    button->radius          = RADIUS_3_PIXELS;

    button->text            = (const char *) PIC(buttonInfo->text);

    button->fontId          = BAGL_FONT_OPEN_SANS_REGULAR_11px_1bpp;

    button->icon            = (const nbgl_icon_details_t *) PIC(buttonInfo->icon);

    button->obj.area.width  = nbgl_getTextWidth(button->fontId, button->text) + BUTTON_MARGIN_Y;

    button->obj.area.height = 14;

    layoutAddObject(layoutInt, (nbgl_obj_t *) button);


    return 0;

}


int nbgl_layoutAddSwitch(nbgl_layout_t *layout, const nbgl_layoutSwitch_t *switchLayout)

{

    nbgl_layoutInternal_t *layoutInt = (nbgl_layoutInternal_t *) layout;

    nbgl_button_t         *button;

    nbgl_text_area_t      *textArea;


    LOG_DEBUG(LAYOUT_LOGGER, "nbgl_layoutAddSwitch():\n");

    if (layout == NULL) {

        return -1;

    }

    // add switch name as title

    textArea                 = (nbgl_text_area_t *) nbgl_objPoolGet(TEXT_AREA, layoutInt->layer);

    textArea->textColor      = WHITE;

    textArea->text           = PIC(switchLayout->text);

    textArea->textAlignment  = CENTER;

    textArea->fontId         = BAGL_FONT_OPEN_SANS_EXTRABOLD_11px_1bpp;

    textArea->obj.area.width = AVAILABLE_WIDTH;

    textArea->wrapping       = true;

    uint16_t nbLines

        = nbgl_getTextNbLinesInWidth(textArea->fontId, textArea->text, AVAILABLE_WIDTH, true);

    // if more than 1 line on screen

    if (nbLines > 1) {

        // TODO: warning for screenshots

        return -1;

    }

    textArea->obj.area.height      = nbgl_getFontLineHeight(textArea->fontId);

    textArea->obj.alignment        = TOP_MIDDLE;

    textArea->obj.alignmentMarginY = 3;

    layoutAddObject(layoutInt, (nbgl_obj_t *) textArea);


    if (switchLayout->subText != NULL) {

        // add switch description

        textArea                = (nbgl_text_area_t *) nbgl_objPoolGet(TEXT_AREA, layoutInt->layer);

        textArea->textColor     = WHITE;

        textArea->text          = PIC(switchLayout->subText);

        textArea->textAlignment = CENTER;

        textArea->fontId        = BAGL_FONT_OPEN_SANS_REGULAR_11px_1bpp;

        textArea->obj.area.width  = AVAILABLE_WIDTH;

        textArea->obj.area.height = 2 * nbgl_getFontLineHeight(textArea->fontId);

        textArea->wrapping        = true;

        nbLines

            = nbgl_getTextNbLinesInWidth(textArea->fontId, textArea->text, AVAILABLE_WIDTH, true);

        // if more than 2 lines on screen

        if (nbLines > 2) {

            // TODO: warning for screenshots

            return -1;

        }

        textArea->obj.alignment        = CENTER;

        textArea->obj.alignmentMarginY = 1;  // not exactly centered

        layoutAddObject(layoutInt, (nbgl_obj_t *) textArea);

    }


    button = (nbgl_button_t *) nbgl_objPoolGet(BUTTON, ((nbgl_layoutInternal_t *) layout)->layer);

    button->foregroundColor = BLACK;

    button->innerColor      = WHITE;

    button->borderColor     = WHITE;

    button->radius          = RADIUS_3_PIXELS;

    button->text            = (switchLayout->initState == ON_STATE) ? "Enabled" : "Disabled";

    button->fontId          = BAGL_FONT_OPEN_SANS_EXTRABOLD_11px_1bpp;

    button->icon = (switchLayout->initState == ON_STATE) ? &C_Switch_On_8px : &C_Switch_Off_8px;

    // 2 pixels between icon & text, and 4 pixels on each side

    button->obj.area.width

        = nbgl_getTextWidth(button->fontId, button->text) + 2 + C_Switch_Off_8px.width + 8;

    button->obj.area.height      = 12;

    button->obj.alignment        = BOTTOM_MIDDLE;

    button->obj.alignmentMarginY = 3;

    layoutAddObject(layoutInt, (nbgl_obj_t *) button);


    return 0;

}


int nbgl_layoutDraw(nbgl_layout_t *layoutParam)

{

    nbgl_layoutInternal_t *layout = (nbgl_layoutInternal_t *) layoutParam;


    if (layout == NULL) {

        return -1;

    }

    LOG_DEBUG(LAYOUT_LOGGER, "nbgl_layoutDraw(): layout->nbChildren = %d\n", layout->nbChildren);

    nbgl_screenRedraw();


    return 0;

}


int nbgl_layoutRelease(nbgl_layout_t *layoutParam)

{

    nbgl_layoutInternal_t *layout = (nbgl_layoutInternal_t *) layoutParam;

    LOG_DEBUG(PAGE_LOGGER, "nbgl_layoutRelease(): \n");

    if (layout == NULL) {

        return -1;

    }

    // if modal

    if (layout->modal) {

        nbgl_screenPop(layout->layer);

    }

    layout->nbChildren = 0;

    return 0;

}

#endif  // HAVE_SE_TOUCH

lcx_rng.h
Random Number Generation.

nbgl_contentCenteredInfoStyle_t
nbgl_contentCenteredInfoStyle_t
possible styles for Centered Info Area
Definition nbgl_content.h:33

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

LAYOUT_LOGGER
@ LAYOUT_LOGGER
Definition nbgl_debug.h:33

PAGE_LOGGER
@ PAGE_LOGGER
Definition nbgl_debug.h:34

nbgl_draw.h
Middle Level API of the new BOLOS Graphical Library.

nbgl_getTextMaxLenAndWidth
void nbgl_getTextMaxLenAndWidth(nbgl_font_id_e fontId, const char *text, uint16_t maxWidth, uint16_t *len, uint16_t *width, bool wrapping)

nbgl_getTextMaxLenInNbLines
bool nbgl_getTextMaxLenInNbLines(nbgl_font_id_e fontId, const char *text, uint16_t maxWidth, uint16_t maxNbLines, uint16_t *len, bool wrapping)

BAGL_FONT_OPEN_SANS_REGULAR_11px_1bpp
@ BAGL_FONT_OPEN_SANS_REGULAR_11px_1bpp
Definition nbgl_fonts.h:150

BAGL_FONT_OPEN_SANS_EXTRABOLD_11px_1bpp
@ BAGL_FONT_OPEN_SANS_EXTRABOLD_11px_1bpp
Definition nbgl_fonts.h:148

nbgl_getTextWidth
uint16_t nbgl_getTextWidth(nbgl_font_id_e fontId, const char *text)

nbgl_getTextNbLinesInWidth
uint16_t nbgl_getTextNbLinesInWidth(nbgl_font_id_e fontId, const char *text, uint16_t maxWidth, bool wrapping)

nbgl_getFont
const nbgl_font_t * nbgl_getFont(nbgl_font_id_e fontId)

nbgl_getTextHeight
uint16_t nbgl_getTextHeight(nbgl_font_id_e fontId, const char *text)

nbgl_getFontLineHeight
uint8_t nbgl_getFontLineHeight(nbgl_font_id_e fontId)

nbgl_front.h
Font screen low-Level driver API, to draw elementary forms.

NB_MAX_LAYOUTS
#define NB_MAX_LAYOUTS
Definition nbgl_layout.c:40

layoutAddObject
void layoutAddObject(nbgl_layoutInternal_t *layout, nbgl_obj_t *obj)
adds the given obj to the main container
Definition nbgl_layout.c:677

NB_MAX_LINES
#define NB_MAX_LINES
Definition nbgl_layout.h:137

HORIZONTAL_NAV
@ HORIZONTAL_NAV
'<' and '>' are displayed, to navigate between pages and steps
Definition nbgl_layout.h:204

nbgl_layoutAddText
int nbgl_layoutAddText(nbgl_layout_t *layout, const char *text, const char *subText)
Creates an area with given text (in bold) and sub text (in regular)
Definition nbgl_layout.c:1450

LEFT_ARROW
@ LEFT_ARROW
left arrow is used
Definition nbgl_layout.h:214

RIGHT_ARROW
@ RIGHT_ARROW
right arrow is used
Definition nbgl_layout.h:215

nbgl_layoutAddCenteredInfo
int nbgl_layoutAddCenteredInfo(nbgl_layout_t *layout, const nbgl_layoutCenteredInfo_t *info)
Creates an area on the center of the main panel, with a possible icon/image, a possible text in black...
Definition nbgl_layout.c:1744

nbgl_layoutDraw
int nbgl_layoutDraw(nbgl_layout_t *layout)
Applies given layout. The screen will be redrawn.
Definition nbgl_layout.c:3848

AVAILABLE_WIDTH
#define AVAILABLE_WIDTH
Definition nbgl_layout.h:134

nbgl_layout_t
void * nbgl_layout_t
type shared externally
Definition nbgl_layout.h:161

nbgl_layoutAddSwitch
int nbgl_layoutAddSwitch(nbgl_layout_t *layout, const nbgl_layoutSwitch_t *switchLayout)
Creates a switch with the given text and its state.
Definition nbgl_layout.c:1412

nbgl_layoutAddButton
int nbgl_layoutAddButton(nbgl_layout_t *layout, const nbgl_layoutButton_t *buttonInfo)
Creates a rounded button in the main container.
Definition nbgl_layout.c:2404

nbgl_layoutGet
nbgl_layout_t * nbgl_layoutGet(const nbgl_layoutDescription_t *description)
returns a layout of the given type. The layout is reset
Definition nbgl_layout.c:1097

nbgl_layoutAddProgressBar
int nbgl_layoutAddProgressBar(nbgl_layout_t *layout, const char *text, const char *subText, uint8_t percentage)
Creates an area in main panel to display a progress bar, with a title text and a subtext if needed.
Definition nbgl_layout.c:2284

nbgl_layoutButtonCallback_t
void(* nbgl_layoutButtonCallback_t)(nbgl_layout_t *layout, nbgl_buttonEvent_t event)
prototype of function to be called when buttons are touched on a screen
Definition nbgl_layout.h:176

nbgl_layoutRelease
int nbgl_layoutRelease(nbgl_layout_t *layout)
Release the layout obtained with nbgl_layoutGet()
Definition nbgl_layout.c:3878

NB_MAX_SCREEN_CHILDREN
@ NB_MAX_SCREEN_CHILDREN
Definition nbgl_layout_internal.h:70

nbgl_layout_internal_nanos.h
Internal functions/constants of NBGL layout layer.

nbgl_obj.h
API to draw all basic graphic objects.

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_containerPoolGet
nbgl_obj_t ** nbgl_containerPoolGet(uint8_t nbObjs, uint8_t layer)

nbgl_objPoolGet
nbgl_obj_t * nbgl_objPoolGet(nbgl_obj_type_t type, uint8_t layer)

nbgl_buttonEvent_t
nbgl_buttonEvent_t
Definition nbgl_obj.h:313

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_buttonCallback_t
void(* nbgl_buttonCallback_t)(void *obj, nbgl_buttonEvent_t buttonEvent)
prototype of function to be called when a button event is received by an object (TODO: change to scre...
Definition nbgl_obj.h:331

nbgl_container_t
struct PACKED__ nbgl_container_s nbgl_container_t
struct to represent a container (CONTAINER type)

nbgl_obj_t
struct PACKED__ nbgl_obj_s nbgl_obj_t
Common structure for all graphical objects.

nbgl_screen.h
API to manage screens.

nbgl_screenSet
int nbgl_screenSet(nbgl_obj_t ***elements, uint8_t nbElements, const nbgl_screenTickerConfiguration_t *ticker, nbgl_touchCallback_t touchCallback)

nbgl_screenPush
int nbgl_screenPush(nbgl_obj_t ***elements, uint8_t nbElements, const nbgl_screenTickerConfiguration_t *ticker, nbgl_touchCallback_t touchCallback)

nbgl_screen_t
struct PACKED__ nbgl_screen_s nbgl_screen_t
struct to represent a screen (SCREEN type)

nbgl_screenPop
int nbgl_screenPop(uint8_t screenIndex)

nbgl_screenContainsObjType
nbgl_obj_t * nbgl_screenContainsObjType(nbgl_screen_t *screen, nbgl_obj_type_t type)

nbgl_screenRedraw
void nbgl_screenRedraw(void)

nbgl_touch.h

WHITE
@ WHITE
Definition nbgl_types.h:144

BLACK
@ BLACK
Definition nbgl_types.h:141

ON_STATE
@ ON_STATE
Definition nbgl_types.h:201

VERTICAL
@ VERTICAL
from top to bottom
Definition nbgl_types.h:209

MIN
#define MIN(x, y)
Definition nbgl_types.h:118

nbgl_icon_details_t
struct PACKED__ nbgl_icon_details_s nbgl_icon_details_t
Represents all information about an icon.

TOP_MIDDLE
@ TOP_MIDDLE
Definition nbgl_types.h:182

CENTER
@ CENTER
Definition nbgl_types.h:185

NO_ALIGNMENT
@ NO_ALIGNMENT
used when parent container layout is used
Definition nbgl_types.h:180

MID_RIGHT
@ MID_RIGHT
Definition nbgl_types.h:186

MID_LEFT
@ MID_LEFT
Definition nbgl_types.h:184

BOTTOM_MIDDLE
@ BOTTOM_MIDDLE
Definition nbgl_types.h:188

KEYPAD
@ KEYPAD
Keypad.
Definition nbgl_types.h:167

IMAGE
@ IMAGE
Bitmap (y and height must be multiple of 4 on Stax)
Definition nbgl_types.h:157

BUTTON
@ BUTTON
Rounded rectangle button with icon and/or text.
Definition nbgl_types.h:160

PROGRESS_BAR
@ PROGRESS_BAR
horizontal bar to indicate progression of something (between 0% and 100%)
Definition nbgl_types.h:163

KEYBOARD
@ KEYBOARD
Keyboard.
Definition nbgl_types.h:166

CONTAINER
@ CONTAINER
Empty container.
Definition nbgl_types.h:156

TEXT_AREA
@ TEXT_AREA
Area to contain text line(s)
Definition nbgl_types.h:159

NBGL_BPP_1
@ NBGL_BPP_1
1 bit per pixel
Definition nbgl_types.h:283

NO_STYLE
@ NO_STYLE
no border
Definition nbgl_types.h:218

nbgl_contentCenteredInfo_t
This structure contains info to build a centered (vertically and horizontally) area,...
Definition nbgl_content.h:57

nbgl_contentCenteredInfo_t::text2
const char * text2
second text (can be null)
Definition nbgl_content.h:59

nbgl_contentCenteredInfo_t::text1
const char * text1
first text (can be null)
Definition nbgl_content.h:58

nbgl_contentCenteredInfo_t::onTop
bool onTop
if set to true, align only horizontally
Definition nbgl_content.h:64

nbgl_contentCenteredInfo_t::style
nbgl_contentCenteredInfoStyle_t style
style to apply to this info
Definition nbgl_content.h:65

nbgl_contentCenteredInfo_t::icon
const nbgl_icon_details_t * icon
a buffer containing the 1BPP icon
Definition nbgl_content.h:63

nbgl_contentSwitch_t
This structure contains info to build a switch (on the right) with a description (on the left),...
Definition nbgl_content.h:264

nbgl_contentSwitch_t::text
const char * text
main text for the switch
Definition nbgl_content.h:265

nbgl_contentSwitch_t::initState
nbgl_state_t initState
initial state of the switch
Definition nbgl_content.h:268

nbgl_contentSwitch_t::subText
const char * subText
description under main text (NULL terminated, single line, may be null)
Definition nbgl_content.h:267

nbgl_font_t
structure defining an ASCII font
Definition nbgl_fonts.h:86

nbgl_font_t::line_height
uint8_t line_height
height of a line for all characters in pixels
Definition nbgl_fonts.h:91

nbgl_layoutButton_t
This structure contains info to build a single button.
Definition nbgl_layout.h:466

nbgl_layoutButton_t::text
const char * text
button text
Definition nbgl_layout.h:467

nbgl_layoutButton_t::icon
const nbgl_icon_details_t * icon
a buffer containing the 1BPP icon for button
Definition nbgl_layout.h:468

nbgl_layoutDescription_s
Structure containing all information when creating a layout. This structure must be passed as argumen...
Definition nbgl_layout.h:234

nbgl_layoutDescription_s::modal
bool modal
Definition nbgl_layout.h:235

nbgl_layoutDescription_s::ticker
nbgl_screenTickerConfiguration_t ticker
Definition nbgl_layout.h:251

nbgl_layoutDescription_s::onActionCallback
nbgl_layoutTouchCallback_t onActionCallback
the callback to be called on any action on the layout
Definition nbgl_layout.h:246

nbgl_layoutInternal_s
Structure containing all information about the current layout.
Definition nbgl_layout_internal.h:78

nbgl_layoutInternal_s::layer
uint8_t layer
layer in screen stack
Definition nbgl_layout_internal.h:104

nbgl_layoutInternal_s::callback
nbgl_layoutTouchCallback_t callback
user callback for all controls
Definition nbgl_layout_internal.h:88

nbgl_layoutInternal_s::nbChildren
uint8_t nbChildren
number of children in above array
Definition nbgl_layout_internal_nanos.h:42

nbgl_layoutInternal_s::modal
uint8_t modal
if true, means the screen is a modal
Definition nbgl_layout_internal.h:100

nbgl_layoutInternal_s::children
nbgl_obj_t ** children
children for main screen
Definition nbgl_layout_internal.h:81

nbgl_layoutMenuList_t
This structure contains a list of names to build a menu list on Nanos, with for each item a descripti...
Definition nbgl_layout.h:307

nbgl_layoutMenuList_t::callback
nbgl_menuListCallback_t callback
function to call to retrieve a menu list item text
Definition nbgl_layout.h:308

nbgl_layoutMenuList_t::nbChoices
uint8_t nbChoices
total number of choices in the menu list
Definition nbgl_layout.h:309

nbgl_layoutMenuList_t::selectedChoice
uint8_t selectedChoice
index of the selected choice (centered, in bold)
Definition nbgl_layout.h:310

nbgl_layoutNavigation_t
This structure contains info to build a navigation bar at the bottom of the screen.
Definition nbgl_layout.h:223

nbgl_layoutNavigation_t::direction
nbgl_layoutNavDirection_t direction
vertical or horizontal navigation
Definition nbgl_layout.h:224

nbgl_layoutNavigation_t::indication
nbgl_layoutNavIndication_t indication
specifies which arrows to use (left or right)
Definition nbgl_layout.h:225

nbgl_layoutProgressBar_t
This structure contains info to build a progress bar with info. The progress bar itself is 120px widt...
Definition nbgl_layout.h:652

nbgl_layoutProgressBar_t::percentage
uint8_t percentage
percentage of completion, from 0 to 100.
Definition nbgl_layout.h:653

nbgl_layoutProgressBar_t::text
const char * text
text in black, on top of progress bar
Definition nbgl_layout.h:654

nbgl_layoutProgressBar_t::subText
const char * subText
text in gray, under progress bar
Definition nbgl_layout.h:655