dialog.c

Go to the documentation of this file.

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////
    #define     DIALOG_C


// ////////////////////////////////////////////////////////////////////////////
// Includes
// ////////////////////////////////////////////////////////////////////////////

    #include    "dialog.h"
    #include    "sralloc.h"



// ////////////////////////////////////////////////////////////////////////////
// Local Defines
// ////////////////////////////////////////////////////////////////////////////

#define DIALOG_LETTERS_COUNT        sizeof(_LetterList)
#define DIALOG_CAPITALS_COUNT       sizeof(_CapitalList)
#define DIALOG_WHITESPACE_COUNT     1
#define DIALOG_NUMBERS_COUNT        sizeof(_NumberList)
#define DIALOG_DASH_COUNT           1
#define DIALOG_SPECIAL_COUNT        10


// ////////////////////////////////////////////////////////////////////////////
// Local Typedefs
// ////////////////////////////////////////////////////////////////////////////

typedef struct
{
    BYTE * pDispRow;
    BYTE MaxCursorPos;
    BYTE CursorPos;
    BYTE DispRow;
    BYTE ControlFlags;
    BOOL DisplayCursor;
    DialogRetValue_t RetValue;
//  BYTE [] CharSetArray;
} sDialogState;


// ////////////////////////////////////////////////////////////////////////////
// Local variables
// ////////////////////////////////////////////////////////////////////////////

ROM BYTE _LetterList[] = { 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',
     'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x',
     'y', 'z' };

ROM BYTE _CapitalList[] = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I',
     'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
     'Y', 'Z' };

ROM BYTE _NumberList[] = {'0','1','2','3','4','5','6','7','8','9'};

static sDialogState * _psState = NULL;


// ////////////////////////////////////////////////////////////////////////////
// Local function prototypes
// ////////////////////////////////////////////////////////////////////////////

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

BOOL bInitInputDialog(BYTE * pu8DefaultString, BYTE u8AllowedCharacters,
                      BYTE u8DispRow, BYTE u8MaxCursorPos, BYTE u8ControlFlags)
{
    BYTE i;
    BYTE charSetCount;
    BYTE * pCharsList = NULL;

inputDialogGetCharacters:
    // Determine the count of maximum possible input characters:

    charSetCount = 0;
    if (u8AllowedCharacters & DIALOG_LETTERS_FLAG)
    {
        charSetCount = DIALOG_LETTERS_COUNT;
        if (pCharsList)
            memcpypgm2ram(pCharsList, _LetterList, DIALOG_LETTERS_COUNT);
    }
    if (u8AllowedCharacters & DIALOG_CAPITALS_FLAG)
    {
        if (pCharsList)
            memcpypgm2ram(&pCharsList[charSetCount], _CapitalList, DIALOG_CAPITALS_COUNT);
        charSetCount += DIALOG_CAPITALS_COUNT;
    }
    if (u8AllowedCharacters & DIALOG_WHITESPACE_FLAG)
    {
        if (pCharsList)
            pCharsList[charSetCount] = ' ';
        charSetCount++;
    }
    if (u8AllowedCharacters & DIALOG_DASH_FLAG)
    {
        if (pCharsList)
            pCharsList[charSetCount] = '-';
        charSetCount++;
    }
    if (u8AllowedCharacters & DIALOG_NUMBERS_FLAG)
    {
        if (pCharsList)
            memcpypgm2ram(&pCharsList[charSetCount], _NumberList, DIALOG_NUMBERS_COUNT);
        charSetCount += DIALOG_NUMBERS_COUNT;
    }
    if (u8AllowedCharacters & DIALOG_SPECIAL_FLAG)
    {
        if (pCharsList)
            pCharsList[charSetCount] = '.';
        charSetCount++;
    }

    // Obtaining a heap array and prepare the state and character set then:
    if (_psState == NULL)
    {
        _psState = (sDialogState*)SRAMalloc(sizeof(sDialogState)+charSetCount);

        if (_psState==NULL)
            return FALSE;

        pCharsList = (BYTE *)_psState + sizeof(sDialogState);
        goto inputDialogGetCharacters;
    }


    _psState->CursorPos = strlen(pu8DefaultString);
    if (_psState->CursorPos)
    {
        // Trying to find the last character in the corresponding character     
        // list.
        _psState->CursorPos--;
        for(i = 0; i < charSetCount; i++)
        {
            if (pu8DefaultString[_psState->CursorPos] == pCharsList[i])
                break;
        }

        if (i == charSetCount)
            i = 0;
    }   
    else
    {
        // Start with the first character.
        i = 0;
    }


    // Preparing the buttons:
    InputEncoderInit(i, 0, charSetCount-1, 0);
    InputButtonReset(ALL_BTN);


    // Preparing the display:

    _psState->MaxCursorPos = u8MaxCursorPos;
    _psState->DispRow = u8DispRow;

    if (u8DispRow==0)
    {
        _psState->pDispRow = lcdram_row1;
    }
    else
    {
        _psState->pDispRow = lcdram_row2;
    }

    strncpy(_psState->pDispRow, pu8DefaultString, LCD_CHARS_IN_A_ROW);
    _psState->pDispRow[LCD_CHARS_IN_A_ROW] = 0;
    lcd_addr1 = 0;
    lcd_addr2 = 0;
    lcd_status = LCD_CLR_MASK | LCD_ROW1_MASK | LCD_ROW2_MASK;

    if (u8ControlFlags & DIALOG_DESCRIPTION_FLAG)
    {
        memset(lcdram_row2, ' ', LCD_CHARS_IN_A_ROW);
        lcdram_row2[LCD_CHARS_IN_A_ROW] = 0;
        
        if (u8ControlFlags & DIALOG_PREV_FLAG)
        {
            lcdram_row2[0] = 0xFB;  // <<
        }
        if (u8ControlFlags & DIALOG_ESC_FLAG)
        {
            memcpypgm2ram(&lcdram_row2[4], (ROM char *) "ESC", 3);
        }
        if (u8ControlFlags & DIALOG_BACKSPACE_FLAG)
        {
            lcdram_row2[10] = 0x7F; // <-
        }
        if (u8ControlFlags & DIALOG_NEXT_FLAG)
        {
            lcdram_row2[15] = 0xFC; // >>
        }
    }
    _psState->ControlFlags = u8ControlFlags;

    OutEnableCursor(TRUE);
    _psState->DisplayCursor = TRUE;

    return TRUE;
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

BOOL bHandleInputDialog(void)
{
    if (OutIsLCDBusy()==TRUE)
    {
        return FALSE;
    }
    else if (_psState->DisplayCursor == TRUE)
    {
        OutSetCursor(_psState->CursorPos, _psState->DispRow);
        _psState->DisplayCursor = FALSE;
        return FALSE;
    }

    if ((bInputEncoderValueChanged() == TRUE) && (_psState->CursorPos < _psState->MaxCursorPos))
    {
        BYTE*pChar=(BYTE*)_psState+sizeof(sDialogState)+s16InputEncoderGetValue();
        _psState->pDispRow[_psState->CursorPos] = *pChar;
    }
    else if (bInputButtonPushed(ENC_BTN) == TRUE)
    {
        // Next position is selected.
        InputButtonReset(ENC_BTN);

        if ((_psState->pDispRow[_psState->CursorPos]) && 
            (_psState->CursorPos < (_psState->MaxCursorPos-1)))
        {
            InputEncoderSetValue(0, TRUE);
            _psState->CursorPos++;
        }
    }
    else if ((_psState->ControlFlags & DIALOG_BACKSPACE_FLAG) &&
             (bInputButtonPushed(F3_BTN) == TRUE))
    {
        BYTE i = 0;

        // Backspace emulation
        InputButtonReset(F3_BTN);
        _psState->pDispRow[_psState->CursorPos] = ' ';

        if (_psState->CursorPos)
        {
            BYTE*pCharSet = (BYTE*)_psState+sizeof(sDialogState);
            _psState->CursorPos--;
            while(_psState->pDispRow[_psState->CursorPos] != pCharSet[i++]);
        }
        else
        {
            // Display the first character.
            i = 1;
        }
        InputEncoderSetValue(i-1, TRUE);
    }
    else if ((_psState->ControlFlags & DIALOG_NEXT_FLAG) && (bInputButtonPushed(F4_BTN) == TRUE))
    {
        // Dialog is finished with OK!
        _psState->RetValue = DIALOG_FINI_OK;
        return TRUE;
    }
    else if ((_psState->ControlFlags & DIALOG_ESC_FLAG) && (bInputButtonPushed(F2_BTN) == TRUE))
    {
        // Dialog is finished with escape!
        _psState->RetValue = DIALOG_FINI_ESC;
        return TRUE;
    }
    else if ((_psState->ControlFlags & DIALOG_PREV_FLAG) && (bInputButtonPushed(F1_BTN) == TRUE))
    {
        // Dialog is finished with cancel!
        _psState->RetValue = DIALOG_FINI_CANCEL;
        return TRUE;
    }
    else
    {
        return FALSE;
    }

    lcd_status = LCD_ROW1_MASK | LCD_ROW2_MASK;
    _psState->DisplayCursor = TRUE;

    return FALSE;
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

DialogRetValue_t FiniDialog(BYTE * pResultString)
{
    DialogRetValue_t ret;
    ret = _psState->RetValue;

    if (_psState == NULL)
    {
        return DIALOG_FINI_CANCEL;
    }

    if ((ret == DIALOG_FINI_OK) && (pResultString))
    {
        strncpy(pResultString, _psState->pDispRow, _psState->MaxCursorPos);
        pResultString[_psState->MaxCursorPos] = 0;
    }

    OutEnableCursor(FALSE);
    InputButtonReset(ALL_BTN);


    SRAMfree((BYTE *)_psState);
    _psState = NULL;

    return ret;
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

---