nbgl_step.c

Go to the documentation of this file.

 
#ifdef NBGL_STEP
/*********************
 *      INCLUDES
 *********************/
#include <string.h>
#include "nbgl_debug.h"
#include "nbgl_step.h"
#include "glyphs.h"
#include "os_pic.h"
#include "os_print.h"
#ifdef BUILD_SCREENSHOTS
#include "json_scenario.h"
#endif  // BUILD_SCREENSHOTS
 
/*********************
 *      DEFINES
 *********************/
// string to store the title for a multi-pages text+subtext
#define TMP_STRING_MAX_LEN 24
 
#define NB_MAX_LAYERS 3
 
/**********************
 *      TYPEDEFS
 **********************/
typedef enum {
    TEXT_STEP = 0,       
    CENTERED_INFO_STEP,  
    MENU_LIST_STEP       
} StepStype_t;
 
typedef struct TextContext_s {
    uint8_t     nbPages;        
    uint8_t     currentPage;    
    const char *txtStart;       
    const char *nextPageStart;  
    const char *subTxtStart;    
 
    nbgl_stepPosition_t pos;  
    bool                actionOnAnyButton;       
    nbgl_stepButtonCallback_t onActionCallback;  
    char tmpString[TMP_STRING_MAX_LEN];          
    nbgl_contentCenteredInfoStyle_t
        style;  
} TextContext_t;
 
typedef struct MenuListContext_s {
    nbgl_stepMenuListCallback_t
        selectedCallback;  
    nbgl_layoutMenuList_t
        list;  
} MenuListContext_t;
 
typedef struct StepContext_s {
    union {
        TextContext_t     textContext;  
        MenuListContext_t menuListContext;  
    };
    nbgl_screenTickerConfiguration_t ticker;  
    nbgl_layout_t                   *layout;  
    StepStype_t                      type;    
    bool                             modal;   
} StepContext_t;
 
/**********************
 *  STATIC VARIABLES
 **********************/
static StepContext_t contexts[NB_MAX_LAYERS];
 
/**********************
 *  VARIABLES
 **********************/
#ifdef BUILD_SCREENSHOTS
// Variables used to store important values (nb lines, bold state etc)
extern uint16_t last_nb_lines;
extern uint16_t last_nb_pages;
extern bool     last_bold_state;
#endif  // BUILD_SCREENSHOTS
 
/**********************
 *  STATIC PROTOTYPES
 **********************/
 
static void actionCallback(nbgl_layout_t *layout, nbgl_buttonEvent_t event);
static void menuListActionCallback(nbgl_layout_t *layout, nbgl_buttonEvent_t event);
 
// returns a non-used step context from the contexts[] array, or NULL if not found
static StepContext_t *getFreeContext(StepStype_t type, bool modal)
{
    StepContext_t *ctx = NULL;
 
    if (!modal) {
        // Index 0 is reserved for background
        ctx = &contexts[0];
    }
    else {
        uint32_t i = 1;
        while (i < NB_MAX_LAYERS) {
            if (contexts[i].layout == NULL) {
                ctx = &contexts[i];
                break;
            }
            i++;
        }
    }
    if (ctx == NULL) {
        LOG_FATAL(STEP_LOGGER, "getFreeContext(): no available context\n");
    }
    else {
        memset(ctx, 0, sizeof(StepContext_t));
        ctx->type  = type;
        ctx->modal = modal;
    }
    return ctx;
}
 
// returns the step context from the contexts[] array matching with the given layout handler, or
// NULL if not found
static StepContext_t *getContextFromLayout(nbgl_layout_t layout)
{
    StepContext_t *ctx = NULL;
    uint32_t       i   = 0;
    while (i < NB_MAX_LAYERS) {
        if (contexts[i].layout == layout) {
            ctx = &contexts[i];
            break;
        }
        i++;
    }
    if (ctx == NULL) {
        LOG_WARN(STEP_LOGGER, "getContextFromLayout(): no matching context\n");
    }
    return ctx;
}
 
// from the current details context, return a pointer on the details at the given page
static const char *getTextPageAt(StepContext_t *ctx, uint8_t textPage)
{
    uint8_t     page        = 0;
    const char *currentChar = ctx->textContext.txtStart;
    while (page < textPage) {
        if (page < (ctx->textContext.nbPages - 1)) {
            uint16_t len;
            nbgl_getTextMaxLenInNbLines(BAGL_FONT_OPEN_SANS_REGULAR_11px_1bpp,
                                        currentChar,
                                        AVAILABLE_WIDTH,
                                        NB_MAX_LINES,
                                        &len,
                                        true);
            currentChar = currentChar + len;
        }
        page++;
    }
    return currentChar;
}
 
// from the current details context, return a pointer on the details at the given page, for subText
static const char *getSubTextPageAt(StepContext_t *ctx, uint8_t textPage)
{
    uint8_t     page        = 0;
    const char *currentChar = ctx->textContext.subTxtStart;
    while (page < textPage) {
        if (page < (ctx->textContext.nbPages - 1)) {
            uint16_t len;
            nbgl_getTextMaxLenInNbLines(BAGL_FONT_OPEN_SANS_REGULAR_11px_1bpp,
                                        currentChar,
                                        AVAILABLE_WIDTH,
                                        NB_MAX_LINES - 1,
                                        &len,
                                        true);
            currentChar = currentChar + len;
        }
        page++;
    }
    return currentChar;
}
 
// utility function to compute navigation arrows
static nbgl_layoutNavIndication_t getNavigationInfo(nbgl_stepPosition_t pos,
                                                    uint8_t             nbPages,
                                                    uint8_t             currentPage)
{
    nbgl_layoutNavIndication_t indication = NO_ARROWS;
 
    if (nbPages > 1) {
        if (currentPage > 0) {
            indication |= LEFT_ARROW;
        }
        if (currentPage < (nbPages - 1)) {
            indication |= RIGHT_ARROW;
        }
    }
    if (pos == FIRST_STEP) {
        indication |= RIGHT_ARROW;
    }
    else if (pos == LAST_STEP) {
        indication |= LEFT_ARROW;
    }
    else if (pos == NEITHER_FIRST_NOR_LAST_STEP) {
        indication |= RIGHT_ARROW | LEFT_ARROW;
    }
    return indication;
}
 
// function used to display the current page in details review mode
static void displayTextPage(StepContext_t *ctx, uint8_t textPage)
{
    const char *txt;
    char        intermediateString[36];  // a bit bigger but we know that one line cannot contain
                                         // more than 23 chars
 
    // if move backward or first page
    if (textPage <= ctx->textContext.currentPage) {
        // recompute current start from beginning
        if (ctx->textContext.subTxtStart == NULL) {
            txt = getTextPageAt(ctx, textPage);
        }
        else {
            txt = getSubTextPageAt(ctx, textPage);
        }
    }
    // else move forward
    else {
        txt = ctx->textContext.nextPageStart;
    }
    ctx->textContext.currentPage = textPage;
 
    if (ctx->textContext.currentPage < (ctx->textContext.nbPages - 1)) {
        uint16_t len;
        uint8_t  nbLines
            = (ctx->textContext.subTxtStart == NULL) ? NB_MAX_LINES : (NB_MAX_LINES - 1);
        nbgl_getTextMaxLenInNbLines(
            BAGL_FONT_OPEN_SANS_REGULAR_11px_1bpp, txt, AVAILABLE_WIDTH, nbLines, &len, true);
        // memorize next position to save processing
        ctx->textContext.nextPageStart = txt + len;
        // if the next char is '\n', skip it to avoid starting with an empty line
        if (*ctx->textContext.nextPageStart == '\n') {
            ctx->textContext.nextPageStart++;
        }
    }
    else {
        ctx->textContext.nextPageStart = NULL;
    }
    nbgl_layoutDescription_t layoutDescription = {0};
    nbgl_layoutNavigation_t  navInfo           = {
                   .direction = HORIZONTAL_NAV,
    };
 
    layoutDescription.modal                  = ctx->modal;
    layoutDescription.onActionCallback       = actionCallback;
    layoutDescription.ticker.tickerCallback  = ctx->ticker.tickerCallback;
    layoutDescription.ticker.tickerIntervale = ctx->ticker.tickerIntervale;
    layoutDescription.ticker.tickerValue     = ctx->ticker.tickerValue;
    ctx->layout                              = nbgl_layoutGet(&layoutDescription);
 
    navInfo.indication = getNavigationInfo(
        ctx->textContext.pos, ctx->textContext.nbPages, ctx->textContext.currentPage);
 
    if (ctx->textContext.subTxtStart == NULL) {
        nbgl_layoutAddText(ctx->layout, txt, NULL, ctx->textContext.style);
    }
    else {
        if (ctx->textContext.nbPages == 1) {
            // truncate title to fit in one line, if necessary
            if (nbgl_getTextNbLinesInWidth(BAGL_FONT_OPEN_SANS_EXTRABOLD_11px_1bpp,
                                           ctx->textContext.txtStart,
                                           AVAILABLE_WIDTH,
                                           false)
                > 1) {
                nbgl_textReduceOnNbLines(BAGL_FONT_OPEN_SANS_EXTRABOLD_11px_1bpp,
                                         ctx->textContext.txtStart,
                                         AVAILABLE_WIDTH,
                                         1,
                                         ctx->textContext.tmpString,
                                         TMP_STRING_MAX_LEN);
            }
            else {
                if (ctx->textContext.txtStart != NULL) {
                    // simply copy
                    memcpy(ctx->textContext.tmpString,
                           ctx->textContext.txtStart,
                           TMP_STRING_MAX_LEN - 1);
                    ctx->textContext.tmpString[TMP_STRING_MAX_LEN - 1] = 0;
                }
                else {
                    ctx->textContext.tmpString[0] = 0;
                }
            }
        }
        else {
            SPRINTF(intermediateString,
                    "%s (%d/%d)",
                    ctx->textContext.txtStart,
                    ctx->textContext.currentPage + 1,
                    ctx->textContext.nbPages);
            // truncate title to fit in one line, if necessary
            if (nbgl_getTextNbLinesInWidth(BAGL_FONT_OPEN_SANS_EXTRABOLD_11px_1bpp,
                                           intermediateString,
                                           AVAILABLE_WIDTH,
                                           false)
                > 1) {
                nbgl_textReduceOnNbLines(BAGL_FONT_OPEN_SANS_EXTRABOLD_11px_1bpp,
                                         intermediateString,
                                         AVAILABLE_WIDTH,
                                         1,
                                         ctx->textContext.tmpString,
                                         TMP_STRING_MAX_LEN);
            }
            else {
                // simply copy
                memcpy(ctx->textContext.tmpString, intermediateString, TMP_STRING_MAX_LEN - 1);
                ctx->textContext.tmpString[TMP_STRING_MAX_LEN - 1] = 0;
            }
        }
        nbgl_layoutAddText(ctx->layout, ctx->textContext.tmpString, txt, ctx->textContext.style);
    }
    if (navInfo.indication != NO_ARROWS) {
        nbgl_layoutAddNavigation(ctx->layout, &navInfo);
    }
    nbgl_layoutDraw(ctx->layout);
    nbgl_refresh();
}
 
// callback on key touch
static void actionCallback(nbgl_layout_t *layout, nbgl_buttonEvent_t event)
{
    StepContext_t *ctx = getContextFromLayout(layout);
 
    if (!ctx) {
        LOG_WARN(STEP_LOGGER, "actionCallback(): ctx not found\n");
        return;
    }
    if (event == BUTTON_LEFT_PRESSED) {
        if (ctx->textContext.currentPage > 0) {
            displayTextPage(ctx, ctx->textContext.currentPage - 1);
            return;
        }
        else if ((ctx->textContext.pos == LAST_STEP)
                 || (ctx->textContext.pos == NEITHER_FIRST_NOR_LAST_STEP)
                 || (ctx->textContext.actionOnAnyButton)) {
            if (ctx->textContext.onActionCallback != NULL) {
                ctx->textContext.onActionCallback((nbgl_step_t) ctx, event);
            }
        }
    }
    else if (event == BUTTON_RIGHT_PRESSED) {
        if (ctx->textContext.currentPage < (ctx->textContext.nbPages - 1)) {
            displayTextPage(ctx, ctx->textContext.currentPage + 1);
            return;
        }
        else if ((ctx->textContext.pos == FIRST_STEP)
                 || (ctx->textContext.pos == NEITHER_FIRST_NOR_LAST_STEP)
                 || (ctx->textContext.actionOnAnyButton)) {
            if (ctx->textContext.onActionCallback != NULL) {
                ctx->textContext.onActionCallback((nbgl_step_t) ctx, event);
            }
        }
    }
    else if (event == BUTTON_BOTH_PRESSED) {
        if (ctx->textContext.onActionCallback != NULL) {
            ctx->textContext.onActionCallback((nbgl_step_t) ctx, event);
        }
    }
}
 
static void displayMenuList(StepContext_t *ctx)
{
    nbgl_layoutDescription_t layoutDescription
        = {.modal = ctx->modal, .onActionCallback = menuListActionCallback};
    nbgl_layoutMenuList_t *list = &ctx->menuListContext.list;
 
    layoutDescription.ticker.tickerCallback  = ctx->ticker.tickerCallback;
    layoutDescription.ticker.tickerIntervale = ctx->ticker.tickerIntervale;
    layoutDescription.ticker.tickerValue     = ctx->ticker.tickerValue;
 
    ctx->layout = nbgl_layoutGet(&layoutDescription);
    nbgl_layoutAddMenuList(ctx->layout, list);
    if (list->nbChoices > 1) {
        nbgl_layoutNavigation_t navInfo = {.direction = VERTICAL_NAV};
        navInfo.indication              = 0;
        if (list->selectedChoice > 0) {
            navInfo.indication |= LEFT_ARROW;
        }
        if (list->selectedChoice < (list->nbChoices - 1)) {
            navInfo.indication |= RIGHT_ARROW;
        }
 
        if (navInfo.indication != NO_ARROWS) {
            nbgl_layoutAddNavigation(ctx->layout, &navInfo);
        }
    }
    nbgl_layoutDraw(ctx->layout);
    nbgl_refresh();
}
 
// callback on key touch
static void menuListActionCallback(nbgl_layout_t *layout, nbgl_buttonEvent_t event)
{
    StepContext_t *ctx = getContextFromLayout(layout);
    if (!ctx) {
        LOG_WARN(STEP_LOGGER, "menuListActionCallback(): ctx not found\n");
        return;
    }
 
    if (event == BUTTON_LEFT_PRESSED) {
        if (ctx->menuListContext.list.selectedChoice > 0) {
            ctx->menuListContext.list.selectedChoice--;
            displayMenuList(ctx);
        }
    }
    else if (event == BUTTON_RIGHT_PRESSED) {
        if (ctx->menuListContext.list.selectedChoice < (ctx->menuListContext.list.nbChoices - 1)) {
            ctx->menuListContext.list.selectedChoice++;
            displayMenuList(ctx);
        }
    }
    else if (event == BUTTON_BOTH_PRESSED) {
        ctx->menuListContext.selectedCallback(ctx->menuListContext.list.selectedChoice);
    }
}
 
/**********************
 *   GLOBAL FUNCTIONS
 **********************/
 
nbgl_step_t nbgl_stepDrawText(nbgl_stepPosition_t               pos,
                              nbgl_stepButtonCallback_t         onActionCallback,
                              nbgl_screenTickerConfiguration_t *ticker,
                              const char                       *text,
                              const char                       *subText,
                              nbgl_contentCenteredInfoStyle_t   style,
                              bool                              modal)
{
#ifdef BUILD_SCREENSHOTS
    // Initialize a default area
    nbgl_area_t area = {0};
    area.x0 = area.y0 = 0;
    area.width        = AVAILABLE_WIDTH;
    area.height = NB_MAX_LINES * nbgl_getFontLineHeight(BAGL_FONT_OPEN_SANS_REGULAR_11px_1bpp);
#endif  // BUILD_SCREENSHOTS
    StepContext_t *ctx = getFreeContext(TEXT_STEP, modal);
    if (!ctx) {
        LOG_WARN(STEP_LOGGER, "nbgl_stepDrawText(): no free context\n");
        return NULL;
    }
    // initialize context (already set to 0 by getFreeContext())
    ctx->textContext.onActionCallback = onActionCallback;
    if (ticker) {
        ctx->ticker.tickerCallback  = ticker->tickerCallback;
        ctx->ticker.tickerIntervale = ticker->tickerIntervale;
        ctx->ticker.tickerValue     = ticker->tickerValue;
    }
 
    // if no subText, get the number of pages for main text
    if (subText == NULL) {
        ctx->textContext.nbPages = nbgl_getTextNbPagesInWidth(
            BAGL_FONT_OPEN_SANS_REGULAR_11px_1bpp, text, NB_MAX_LINES, AVAILABLE_WIDTH);
#ifdef BUILD_SCREENSHOTS
        store_string_infos(text,
                           BAGL_FONT_OPEN_SANS_REGULAR_11px_1bpp,
                           &area,
                           true,
                           last_nb_lines,
                           last_nb_pages,
                           last_bold_state);
#endif  // BUILD_SCREENSHOTS
    }
    else {
#ifdef BUILD_SCREENSHOTS
        uint16_t nb_lines_title;
        // Call this function to get correct nb_lines/nb_pages for text field.
        nbgl_getTextNbPagesInWidth(
            BAGL_FONT_OPEN_SANS_REGULAR_11px_1bpp, text, NB_MAX_LINES, AVAILABLE_WIDTH);
        nb_lines_title = last_nb_lines;
        // There is a sub text, so no more than 3 lines for title...
        if (nb_lines_title > 3) {
            nb_lines_title = 3;
        }
        area.height
            = nb_lines_title * nbgl_getFontLineHeight(BAGL_FONT_OPEN_SANS_REGULAR_11px_1bpp);
        store_string_infos(text,
                           BAGL_FONT_OPEN_SANS_REGULAR_11px_1bpp,
                           &area,
                           true,
                           last_nb_lines,
                           last_nb_pages,
                           last_bold_state);
#endif  // BUILD_SCREENSHOTS
        // NB_MAX_LINES-1 because first line is for main text
        ctx->textContext.nbPages = nbgl_getTextNbPagesInWidth(
            BAGL_FONT_OPEN_SANS_REGULAR_11px_1bpp, subText, NB_MAX_LINES - 1, AVAILABLE_WIDTH);
#ifdef BUILD_SCREENSHOTS
        area.height = (NB_MAX_LINES - nb_lines_title)
                      * nbgl_getFontLineHeight(BAGL_FONT_OPEN_SANS_REGULAR_11px_1bpp);
        // If subTxtid is not valid, we'll use txtId for nb_lines/nb_pages values
        store_string_infos(subText,
                           BAGL_FONT_OPEN_SANS_REGULAR_11px_1bpp,
                           &area,
                           true,
                           last_nb_lines,
                           last_nb_pages,
                           last_bold_state);
#endif  // BUILD_SCREENSHOTS
    }
    LOG_DEBUG(STEP_LOGGER,
              "nbgl_stepDrawText: ctx = %p, nbPages = %d, pos = 0x%X\n",
              ctx,
              ctx->textContext.nbPages,
              pos);
    if (pos & BACKWARD_DIRECTION) {
        // start with last page
        ctx->textContext.currentPage = ctx->textContext.nbPages - 1;
    }
    ctx->textContext.txtStart    = text;
    ctx->textContext.subTxtStart = subText;
    // keep only direction part of position
    ctx->textContext.pos               = pos & STEP_POSITION_MASK;
    ctx->textContext.actionOnAnyButton = (pos & ACTION_ON_ANY_BUTTON) != 0;
    ctx->textContext.style             = style;
    displayTextPage(ctx, ctx->textContext.currentPage);
 
    return (nbgl_step_t) ctx;
}
 
nbgl_step_t nbgl_stepDrawCenteredInfo(nbgl_stepPosition_t               pos,
                                      nbgl_stepButtonCallback_t         onActionCallback,
                                      nbgl_screenTickerConfiguration_t *ticker,
                                      nbgl_layoutCenteredInfo_t        *info,
                                      bool                              modal)
{
    nbgl_layoutDescription_t layoutDescription
        = {.modal = modal, .onActionCallback = (nbgl_layoutButtonCallback_t) actionCallback};
    nbgl_layoutNavigation_t navInfo = {
        .direction = HORIZONTAL_NAV,
    };
    StepContext_t *ctx = getFreeContext(CENTERED_INFO_STEP, modal);
    if (!ctx) {
        LOG_WARN(STEP_LOGGER, "nbgl_stepDrawCenteredInfo(): no free context\n");
        return NULL;
    }
 
    // initialize context (already set to 0 by getFreeContext())
    ctx->textContext.onActionCallback = onActionCallback;
    if (ticker) {
        ctx->ticker.tickerCallback               = ticker->tickerCallback;
        ctx->ticker.tickerIntervale              = ticker->tickerIntervale;
        ctx->ticker.tickerValue                  = ticker->tickerValue;
        layoutDescription.ticker.tickerCallback  = ticker->tickerCallback;
        layoutDescription.ticker.tickerIntervale = ticker->tickerIntervale;
        layoutDescription.ticker.tickerValue     = ticker->tickerValue;
    }
 
    ctx->textContext.nbPages = 1;
    // keep only direction part of position
    ctx->textContext.pos = pos & (RIGHT_ARROW | LEFT_ARROW);
    navInfo.indication   = getNavigationInfo(
        ctx->textContext.pos, ctx->textContext.nbPages, ctx->textContext.currentPage);
 
    ctx->layout = nbgl_layoutGet(&layoutDescription);
    nbgl_layoutAddCenteredInfo(ctx->layout, info);
    if (navInfo.indication != NO_ARROWS) {
        nbgl_layoutAddNavigation(ctx->layout, &navInfo);
    }
    nbgl_layoutDraw(ctx->layout);
    nbgl_refresh();
 
    LOG_DEBUG(STEP_LOGGER, "nbgl_stepDrawCenteredInfo(): step = %p\n", ctx);
    return (nbgl_step_t) ctx;
}
 
nbgl_step_t nbgl_stepDrawMenuList(nbgl_stepMenuListCallback_t       onActionCallback,
                                  nbgl_screenTickerConfiguration_t *ticker,
                                  nbgl_layoutMenuList_t            *list,
                                  bool                              modal)
{
    StepContext_t *ctx = getFreeContext(MENU_LIST_STEP, modal);
    if (!ctx) {
        LOG_WARN(STEP_LOGGER, "nbgl_stepDrawMenuList(): no free context\n");
        return NULL;
    }
 
    // initialize context (already set to 0 by getFreeContext())
    if (ticker) {
        ctx->ticker.tickerCallback  = ticker->tickerCallback;
        ctx->ticker.tickerIntervale = ticker->tickerIntervale;
        ctx->ticker.tickerValue     = ticker->tickerValue;
    }
 
    ctx->menuListContext.list.nbChoices      = list->nbChoices;
    ctx->menuListContext.list.selectedChoice = list->selectedChoice;
    ctx->menuListContext.list.callback       = list->callback;
    ctx->menuListContext.selectedCallback    = onActionCallback;
 
    displayMenuList(ctx);
 
    LOG_DEBUG(STEP_LOGGER, "nbgl_stepDrawMenuList(): step = %p\n", ctx);
 
    return (nbgl_step_t) ctx;
}
 
uint8_t nbgl_stepGetMenuListCurrent(nbgl_step_t step)
{
    StepContext_t *ctx = (StepContext_t *) step;
    if (!ctx) {
        return 0;
    }
    return (ctx->menuListContext.list.selectedChoice);
}
 
nbgl_step_t nbgl_stepDrawSwitch(nbgl_stepPosition_t               pos,
                                nbgl_stepButtonCallback_t         onActionCallback,
                                nbgl_screenTickerConfiguration_t *ticker,
                                nbgl_layoutSwitch_t              *switchInfo,
                                bool                              modal)
{
    nbgl_layoutDescription_t layoutDescription
        = {.modal = modal, .onActionCallback = (nbgl_layoutButtonCallback_t) actionCallback};
    nbgl_layoutNavigation_t navInfo = {
        .direction = HORIZONTAL_NAV,
    };
    StepContext_t *ctx = getFreeContext(CENTERED_INFO_STEP, modal);
    if (!ctx) {
        LOG_WARN(STEP_LOGGER, "nbgl_stepDrawSwitch(): no free context\n");
        return NULL;
    }
 
    // initialize context (already set to 0 by getFreeContext())
    ctx->textContext.onActionCallback = onActionCallback;
    if (ticker) {
        ctx->ticker.tickerCallback               = ticker->tickerCallback;
        ctx->ticker.tickerIntervale              = ticker->tickerIntervale;
        ctx->ticker.tickerValue                  = ticker->tickerValue;
        layoutDescription.ticker.tickerCallback  = ticker->tickerCallback;
        layoutDescription.ticker.tickerIntervale = ticker->tickerIntervale;
        layoutDescription.ticker.tickerValue     = ticker->tickerValue;
    }
 
    ctx->textContext.nbPages = 1;
    // keep only direction part of position
    ctx->textContext.pos = pos & (RIGHT_ARROW | LEFT_ARROW);
    navInfo.indication   = getNavigationInfo(
        ctx->textContext.pos, ctx->textContext.nbPages, ctx->textContext.currentPage);
 
    ctx->layout = nbgl_layoutGet(&layoutDescription);
    nbgl_layoutAddSwitch(ctx->layout, switchInfo);
    if (navInfo.indication != NO_ARROWS) {
        nbgl_layoutAddNavigation(ctx->layout, &navInfo);
    }
    nbgl_layoutDraw(ctx->layout);
    nbgl_refresh();
 
    LOG_DEBUG(STEP_LOGGER, "nbgl_stepDrawSwitch(): ctx = %p\n", ctx);
    return (nbgl_step_t) ctx;
}
 
int nbgl_stepRelease(nbgl_step_t step)
{
    StepContext_t *ctx = (StepContext_t *) step;
    int            ret;
 
    LOG_DEBUG(STEP_LOGGER, "nbgl_stepRelease(): ctx = %p\n", ctx);
    if (!ctx) {
        return -1;
    }
    ret = nbgl_layoutRelease((nbgl_layout_t *) ctx->layout);
 
    ctx->layout = NULL;
 
    return ret;
}
 
#endif  // NBGL_STEP