nbgl_layout_keypad.c

Go to the documentation of this file.

 
#ifdef HAVE_SE_TOUCH
#ifdef NBGL_KEYPAD
/*********************
 *      INCLUDES
 *********************/
#include <string.h>
#include <stdlib.h>
#include "nbgl_debug.h"
#include "nbgl_front.h"
#include "nbgl_layout_internal.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 "os.h"
 
/*********************
 *      DEFINES
 *********************/
 
enum {
    TITLE_INDEX = 0,
    INPUT_INDEX,
    NB_CHILDREN
};
 
#if defined(TARGET_STAX)
#define ENTRY_DIGITS_LINE_WIDTH       288
#define ENTRY_DIGITS_CONTAINER_HEIGHT 52
#define INTER_ENTRY_DIGITS            10
#define TITLE_MARGIN_Y                8
#define TITLE_MARGIN_Y_SMALL          8
#elif defined(TARGET_FLEX)
#define ENTRY_DIGITS_CONTAINER_HEIGHT 64
#define INTER_ENTRY_DIGITS            12
#define TITLE_MARGIN_Y                8
#define TITLE_MARGIN_Y_SMALL          8
#elif defined(TARGET_APEX)
#define ENTRY_DIGITS_CONTAINER_HEIGHT 40
#define INTER_ENTRY_DIGITS            8
#define TITLE_MARGIN_Y                13
#define TITLE_MARGIN_Y_SMALL          2
#endif  // TARGETS
 
/**********************
 *      MACROS
 **********************/
 
/**********************
 *      TYPEDEFS
 **********************/
 
/**********************
 *      VARIABLES
 **********************/
 
/**********************
 *  STATIC PROTOTYPES
 **********************/
 
/**********************
 *   GLOBAL API FUNCTIONS
 **********************/
 
int nbgl_layoutAddKeypad(nbgl_layout_t *layout, keyboardCallback_t callback, bool shuffled)
{
    nbgl_layoutInternal_t *layoutInt = (nbgl_layoutInternal_t *) layout;
    nbgl_keypad_t         *keypad;
 
    LOG_DEBUG(LAYOUT_LOGGER, "nbgl_layoutAddKeypad():\n");
    if (layout == NULL) {
        return -1;
    }
    // footer must be empty
    if (layoutInt->footerContainer != NULL) {
        LOG_WARN(LAYOUT_LOGGER, "nbgl_layoutAddKeypad(): footer already set\n");
        return -1;
    }
 
    // create keypad
    keypad                       = (nbgl_keypad_t *) nbgl_objPoolGet(KEYPAD, layoutInt->layer);
    keypad->obj.alignmentMarginY = 0;
    keypad->obj.alignment        = BOTTOM_MIDDLE;
    keypad->obj.alignTo          = NULL;
    keypad->obj.area.width       = SCREEN_WIDTH;
    keypad->obj.area.height      = 4 * KEYPAD_KEY_HEIGHT;
    keypad->callback             = PIC(callback);
    keypad->enableDigits         = true;
    keypad->enableBackspace      = false;
    keypad->enableValidate       = false;
    keypad->shuffled             = shuffled;
    keypad->digitsChanged        = true;
    keypad->validateChanged      = true;
 
    // the keypad occupies the footer
    layoutInt->footerContainer = (nbgl_container_t *) nbgl_objPoolGet(CONTAINER, layoutInt->layer);
    layoutInt->footerContainer->obj.area.width = SCREEN_WIDTH;
    layoutInt->footerContainer->layout         = VERTICAL;
    layoutInt->footerContainer->children
        = (nbgl_obj_t **) nbgl_containerPoolGet(1, layoutInt->layer);
    layoutInt->footerContainer->obj.alignment   = BOTTOM_MIDDLE;
    layoutInt->footerContainer->obj.area.height = keypad->obj.area.height;
    layoutInt->footerContainer->children[layoutInt->footerContainer->nbChildren]
        = (nbgl_obj_t *) keypad;
    layoutInt->footerContainer->nbChildren++;
 
    // add to layout children
    layoutInt->children[FOOTER_INDEX] = (nbgl_obj_t *) layoutInt->footerContainer;
 
    // subtract footer height from main container height
    layoutInt->container->obj.area.height -= layoutInt->footerContainer->obj.area.height;
 
    layoutInt->footerType = KEYPAD_FOOTER_TYPE;
 
    return layoutInt->footerContainer->obj.area.height;
}
 
int nbgl_layoutUpdateKeypad(nbgl_layout_t *layout,
                            uint8_t        index,
                            bool           enableValidate,
                            bool           enableBackspace,
                            bool           enableDigits)
{
    nbgl_layoutInternal_t *layoutInt = (nbgl_layoutInternal_t *) layout;
    nbgl_keypad_t         *keypad;
 
    LOG_DEBUG(LAYOUT_LOGGER,
              "nbgl_layoutUpdateKeypad(): enableValidate = %d, enableBackspace = %d\n",
              enableValidate,
              enableBackspace);
    if (layout == NULL) {
        return -1;
    }
    UNUSED(index);
 
    // get existing keypad (in the footer container)
    keypad = (nbgl_keypad_t *) layoutInt->footerContainer->children[0];
    if ((keypad == NULL) || (keypad->obj.type != KEYPAD)) {
        LOG_WARN(LAYOUT_LOGGER, "nbgl_layoutUpdateKeypad(): keypad not found at index %d\n", index);
        return -1;
    }
    // partial redraw only if only validate and backspace have changed
    keypad->digitsChanged   = (keypad->enableDigits != enableDigits);
    keypad->validateChanged = (keypad->enableValidate != enableValidate);
    keypad->enableValidate  = enableValidate;
    keypad->enableBackspace = enableBackspace;
    keypad->enableDigits    = enableDigits;
 
    nbgl_objDraw((nbgl_obj_t *) keypad);
 
    return 0;
}
 
int nbgl_layoutUpdateKeypadValidation(nbgl_layout_t *layout, bool softValidation)
{
    nbgl_layoutInternal_t *layoutInt = (nbgl_layoutInternal_t *) layout;
    nbgl_keypad_t         *keypad;
 
    LOG_DEBUG(LAYOUT_LOGGER, "nbgl_layoutUpdateKeypad(): softValidation = %d,\n", softValidation);
    if (layout == NULL) {
        return -1;
    }
    UNUSED(index);
 
    // get existing keypad (in the footer container)
    keypad = (nbgl_keypad_t *) layoutInt->footerContainer->children[0];
    if ((keypad == NULL) || (keypad->obj.type != KEYPAD)) {
        LOG_WARN(LAYOUT_LOGGER, "nbgl_layoutUpdateKeypadValidation(): keypad not found\n");
        return -1;
    }
    keypad->softValidation = softValidation;
 
    return 0;
}
 
int nbgl_layoutAddKeypadContent(nbgl_layout_t *layout,
                                const char    *title,
                                bool           hidden,
                                uint8_t        nbDigits,
                                const char    *text)
{
    nbgl_layoutInternal_t *layoutInt = (nbgl_layoutInternal_t *) layout;
    nbgl_container_t      *container;
    nbgl_text_area_t      *textArea;
 
    LOG_DEBUG(LAYOUT_LOGGER, "nbgl_layoutAddKeypadContent():\n");
    if (layout == NULL) {
        return -1;
    }
    // create a container, to store both title and "digits" (and line on Stax)
    container                 = (nbgl_container_t *) nbgl_objPoolGet(CONTAINER, layoutInt->layer);
    container->nbChildren     = NB_CHILDREN;
    container->children       = nbgl_containerPoolGet(container->nbChildren, layoutInt->layer);
    container->obj.area.width = AVAILABLE_WIDTH;
    container->obj.alignment  = TOP_MIDDLE;
 
    // create text area for title
    textArea                  = (nbgl_text_area_t *) nbgl_objPoolGet(TEXT_AREA, layoutInt->layer);
    textArea->textColor       = BLACK;
    textArea->text            = title;
    textArea->textAlignment   = CENTER;
    textArea->fontId          = SMALL_REGULAR_FONT;
    textArea->wrapping        = true;
    textArea->obj.alignment   = TOP_MIDDLE;
    textArea->obj.area.width  = AVAILABLE_WIDTH;
    textArea->obj.area.height = nbgl_getTextHeightInWidth(
        textArea->fontId, textArea->text, textArea->obj.area.width, textArea->wrapping);
    if (textArea->obj.area.height > nbgl_getFontHeight(textArea->fontId)) {
        container->obj.alignmentMarginY = TITLE_MARGIN_Y_SMALL;
    }
    else {
        container->obj.alignmentMarginY = TITLE_MARGIN_Y;
    }
    container->children[TITLE_INDEX] = (nbgl_obj_t *) textArea;
    container->obj.area.height += textArea->obj.area.height;
 
    if (hidden) {
        nbgl_container_t *digitsContainer;
        uint8_t           space;
 
        if (nbDigits > KEYPAD_MAX_DIGITS) {
            LOG_WARN(LAYOUT_LOGGER,
                     "nbgl_layoutAddKeypadContent(): nbDigits %d > KEYPAD_MAX_DIGITS %d\n",
                     nbDigits,
                     KEYPAD_MAX_DIGITS);
            return -1;
        }
        // space between "digits"
        if (nbDigits > 8) {
            space = 4;
        }
        else {
            space = INTER_ENTRY_DIGITS;
        }
 
        // create digits container, to store "discs"
        digitsContainer = (nbgl_container_t *) nbgl_objPoolGet(CONTAINER, layoutInt->layer);
        digitsContainer->nbChildren = nbDigits;
#ifdef TARGET_STAX
        // for stax, add line as child
        digitsContainer->nbChildren++;
#endif  // TARGET_STAX
        digitsContainer->children
            = nbgl_containerPoolGet(digitsContainer->nbChildren, layoutInt->layer);
        // <space> pixels between each icon (knowing that the effective round are 18px large and the
        // icon 24px)
#ifdef TARGET_STAX
        digitsContainer->obj.area.width = ENTRY_DIGITS_LINE_WIDTH;
#else   // TARGET_STAX
        digitsContainer->obj.area.width = nbDigits * DIGIT_ICON.width + (nbDigits - 1) * space;
#endif  // TARGET_STAX
        digitsContainer->obj.area.height = ENTRY_DIGITS_CONTAINER_HEIGHT;
        // align at the bottom of title
        digitsContainer->obj.alignTo     = container->children[0];
        digitsContainer->obj.alignment   = BOTTOM_MIDDLE;
        container->children[INPUT_INDEX] = (nbgl_obj_t *) digitsContainer;
        container->obj.area.height += digitsContainer->obj.area.height;
 
        // create children of the container, as images (empty circles)
        nbgl_objPoolGetArray(
            IMAGE, nbDigits, layoutInt->layer, (nbgl_obj_t **) digitsContainer->children);
        for (int i = 0; i < nbDigits; i++) {
            nbgl_image_t *image    = (nbgl_image_t *) digitsContainer->children[i];
            image->buffer          = &DIGIT_ICON;
            image->foregroundColor = WHITE;
            if (i > 0) {
                image->obj.alignment        = MID_RIGHT;
                image->obj.alignTo          = (nbgl_obj_t *) digitsContainer->children[i - 1];
                image->obj.alignmentMarginX = space;
            }
            else {
                image->obj.alignment = MID_LEFT;
            }
        }
#ifdef TARGET_STAX
        nbgl_line_t *line;
        // create gray line
        line                  = (nbgl_line_t *) nbgl_objPoolGet(LINE, layoutInt->layer);
        line->lineColor       = LIGHT_GRAY;
        line->obj.alignTo     = container->children[INPUT_INDEX];
        line->obj.alignment   = BOTTOM_MIDDLE;
        line->obj.area.width  = ENTRY_DIGITS_LINE_WIDTH;
        line->obj.area.height = 4;
        line->direction       = HORIZONTAL;
        line->thickness       = 2;
        line->offset          = 2;
        digitsContainer->children[nbDigits] = (nbgl_obj_t *) line;
        digitsContainer->children[0]->alignmentMarginX
            = (line->obj.area.width - (nbDigits * DIGIT_ICON.width + (nbDigits - 1) * space)) / 2;
#endif  // TARGET_STAX
    }
    else {
        // create text area
        textArea                = (nbgl_text_area_t *) nbgl_objPoolGet(TEXT_AREA, layoutInt->layer);
        textArea->textColor     = BLACK;
        textArea->text          = text;
        textArea->textAlignment = MID_LEFT;
        textArea->fontId        = LARGE_MEDIUM_1BPP_FONT;
        textArea->obj.area.width   = container->obj.area.width;
        textArea->obj.area.height  = nbgl_getFontLineHeight(textArea->fontId);
        textArea->autoHideLongLine = true;
        // align at the bottom of title
        textArea->obj.alignTo   = container->children[TITLE_INDEX];
        textArea->obj.alignment = BOTTOM_MIDDLE;
#ifdef TARGET_STAX
        textArea->obj.alignmentMarginY = 24;
#endif  // TARGET_STAX
        container->children[INPUT_INDEX] = (nbgl_obj_t *) textArea;
        container->obj.area.height += textArea->obj.area.height;
    }
 
    // set this new container as child of the main container
    layoutAddObject(layoutInt, (nbgl_obj_t *) container);
 
    // return height of the area
    return container->obj.area.height;
}
 
int nbgl_layoutUpdateKeypadContent(nbgl_layout_t *layout,
                                   bool           hidden,
                                   uint8_t        nbActiveDigits,
                                   const char    *text)
{
    nbgl_layoutInternal_t *layoutInt = (nbgl_layoutInternal_t *) layout;
    nbgl_container_t      *container;
    nbgl_image_t          *image;
 
    LOG_DEBUG(LAYOUT_LOGGER, "nbgl_layoutUpdateHiddenDigits(): nbActive = %d\n", nbActiveDigits);
    if (layout == NULL) {
        return -1;
    }
 
    UNUSED(index);
 
    if (hidden) {
        // get digits container (second child of the main container)
        container = (nbgl_container_t *) ((nbgl_container_t *) layoutInt->container->children[0])
                        ->children[1];
        // sanity check
        if ((container == NULL) || (container->obj.type != CONTAINER)) {
            LOG_WARN(LAYOUT_LOGGER, "nbgl_layoutUpdateKeypadContent(): container not found\n");
            return -1;
        }
        if (nbActiveDigits > container->nbChildren) {
            LOG_WARN(LAYOUT_LOGGER,
                     "nbgl_layoutUpdateKeypadContent(): nbActive %d > nbChildren %d\n",
                     nbActiveDigits,
                     container->nbChildren);
            return -1;
        }
        if (nbActiveDigits == 0) {
            // deactivate the first digit
            image = (nbgl_image_t *) container->children[0];
            if ((image == NULL) || (image->obj.type != IMAGE)) {
                LOG_WARN(LAYOUT_LOGGER, "nbgl_layoutUpdateKeypadContent(): image not found\n");
                return -1;
            }
            image->foregroundColor = WHITE;
        }
        else {
            image = (nbgl_image_t *) container->children[nbActiveDigits - 1];
            if ((image == NULL) || (image->obj.type != IMAGE)) {
                LOG_WARN(LAYOUT_LOGGER, "nbgl_layoutUpdateKeypadContent(): image not found\n");
                return -1;
            }
            // if the last "active" is already active, it means that we are decreasing the number of
            // active otherwise we are increasing it
            if (image->foregroundColor == BLACK) {
                // all digits are already active
                if (nbActiveDigits == container->nbChildren) {
                    return 0;
                }
                // deactivate the next digit by turning it to white
                image                  = (nbgl_image_t *) container->children[nbActiveDigits];
                image->foregroundColor = WHITE;
            }
            else {
                // activate it the last digit by turning it to black
                image->foregroundColor = BLACK;
            }
        }
 
        nbgl_objDraw((nbgl_obj_t *) image);
    }
    else {
        // update main text area (second child of the main container)
        nbgl_text_area_t *textArea
            = (nbgl_text_area_t *) ((nbgl_container_t *) layoutInt->container->children[0])
                  ->children[1];
        if ((textArea == NULL) || (textArea->obj.type != TEXT_AREA)) {
            LOG_WARN(LAYOUT_LOGGER, "nbgl_layoutUpdateKeypadContent(): text area not found\n");
            return -1;
        }
        textArea->text          = text;
        textArea->textColor     = BLACK;
        textArea->textAlignment = MID_LEFT;
        nbgl_objDraw((nbgl_obj_t *) textArea);
 
        // if the text doesn't fit, indicate it by returning 1 instead of 0, for different refresh
        if (nbgl_getSingleLineTextWidth(textArea->fontId, text) > textArea->obj.area.width) {
            return 1;
        }
    }
 
    return 0;
}
#endif  // NBGL_KEYPAD
#endif  // HAVE_SE_TOUCH