//***************************************************************************** // // Returns information on the glyphs contained within a given font block. // //***************************************************************************** static uint32_t FATWrapperFontBlockCodepointsGet(uint8_t *pui8FontID, uint16_t ui16BlockIndex, uint32_t *pui32Start) { tFontBlock sBlock; tFontFile *psFont; bool bRetcode; // // Parameter sanity check. // ASSERT(pui8FontID); // // Get a pointer to our instance data. // psFont = (tFontFile *)pui8FontID; ASSERT(psFont->bInUse); // // Have we been passed a valid block index? // if(ui16BlockIndex >= psFont->sFontHeader.ui16NumBlocks) { // // No - return an error. // return(0); } // // Is this block header cached? // if(ui16BlockIndex < MAX_FONT_BLOCKS) { // // Yes - return the information from our cached copy. // *pui32Start = psFont->psBlocks[ui16BlockIndex].ui32StartCodepoint; return(psFont->psBlocks[ui16BlockIndex].ui32NumCodepoints); } else { // // We don't have the block header cached so read it from the // SDCard. First move the file pointer to the expected position. // bRetcode = FATWrapperFontBlockHeaderGet(&psFont->sFile, &sBlock, ui16BlockIndex); if(bRetcode) { *pui32Start = sBlock.ui32StartCodepoint; return(sBlock.ui32NumCodepoints); } else { UARTprintf("Error reading block header!\n"); } } // // If we get here, something horrible happened so return a failure. // *pui32Start = 0; return(0); }
//***************************************************************************** // // Retrieves the data for a particular font glyph. This function returns // a pointer to the glyph data in linear, random access memory if the glyph // exists or NULL if not. // //***************************************************************************** static const uint8_t * FATWrapperFontGlyphDataGet(uint8_t *pui8FontID, uint32_t ui32Codepoint, uint8_t *pui8Width) { tFontFile *psFont; uint32_t ui32Loop, ui32GlyphOffset, ui32TableOffset; UINT uiRead; tFontBlock sBlock; tFontBlock *psBlock; bool bRetcode; FRESULT iFResult; // // Parameter sanity check. // ASSERT(pui8FontID); ASSERT(pui8Width); // // If passed a NULL codepoint, return immediately. // if(!ui32Codepoint) { return(0); } // // Get a pointer to our instance data. // psFont = (tFontFile *)pui8FontID; ASSERT(psFont->bInUse); // // Look for the trivial case - do we have this glyph in our glyph store // already? // if(psFont->ui32CurrentGlyph == ui32Codepoint) { // // We struck gold - we already have this glyph in our buffer. Return // the width (from the second byte of the data) and a pointer to the // glyph data. // *pui8Width = psFont->pui8GlyphStore[1]; return(psFont->pui8GlyphStore); } // // First find the block that contains the glyph we've been asked for. // for(ui32Loop = 0; ui32Loop < psFont->sFontHeader.ui16NumBlocks; ui32Loop++) { if(ui32Loop < MAX_FONT_BLOCKS) { psBlock = &psFont->psBlocks[ui32Loop]; } else { bRetcode = FATWrapperFontBlockHeaderGet(&psFont->sFile, &sBlock, ui32Loop); psBlock = &sBlock; if(!bRetcode) { // // We failed to read the block header so return an error. // return(0); } } // // Does the requested character exist in this block? // if((ui32Codepoint >= (psBlock->ui32StartCodepoint)) && ((ui32Codepoint < (psBlock->ui32StartCodepoint + psBlock->ui32NumCodepoints)))) { // // The glyph is in this block. Calculate the offset of it's // glyph table entry in the file. // ui32TableOffset = psBlock->ui32GlyphTableOffset + ((ui32Codepoint - psBlock->ui32StartCodepoint) * sizeof(uint32_t)); // // Move the file pointer to the offset position. // iFResult = f_lseek(&psFont->sFile, ui32TableOffset); if(iFResult != FR_OK) { return(0); } // // Read the glyph data offset. // iFResult = f_read(&psFont->sFile, &ui32GlyphOffset, sizeof(uint32_t), &uiRead); // // Return if there was an error or if the offset is 0 (which // indicates that the character is not included in the font. // if((iFResult != FR_OK) || (uiRead != sizeof(uint32_t)) || !ui32GlyphOffset) { return(0); } // // Move the file pointer to the start of the glyph data remembering // that the glyph table offset is relative to the start of the // block not the start of the file (so we add the table offset // here). // iFResult = f_lseek(&psFont->sFile, (psBlock->ui32GlyphTableOffset + ui32GlyphOffset)); if(iFResult != FR_OK) { return(0); } // // Read the first byte of the glyph data to find out how long it // is. // iFResult = f_read(&psFont->sFile, psFont->pui8GlyphStore, 1, &uiRead); if((iFResult != FR_OK) || !uiRead) { return(0); } // // Now read the glyph data. // iFResult = f_read(&psFont->sFile, psFont->pui8GlyphStore + 1, psFont->pui8GlyphStore[0] - 1, &uiRead); if((iFResult != FR_OK) || (uiRead != (psFont->pui8GlyphStore[0] - 1))) { return(0); } // // If we get here, things are good. Return a pointer to the glyph // store data. // psFont->ui32CurrentGlyph = ui32Codepoint; *pui8Width = psFont->pui8GlyphStore[1]; return(psFont->pui8GlyphStore); } } // // If we get here, the codepoint doesn't exist in the font so return an // error. // return(0); }
//***************************************************************************** // // Returns information on the glyphs contained within a given font block. // //***************************************************************************** static unsigned long FATWrapperFontBlockCodepointsGet(unsigned char *pucFontId, unsigned short usBlockIndex, unsigned long *pulStart) { tFontBlock sBlock; tFontFile *pFont; tBoolean bRetcode; // // Parameter sanity check. // ASSERT(pucFontId); // // Get a pointer to our instance data. // pFont = (tFontFile *)pucFontId; ASSERT(pFont->bInUse); // // Have we been passed a valid block index? // if(usBlockIndex >= pFont->sFontHeader.usNumBlocks) { // // No - return an error. // return(0); } // // Is this block header cached? // if(usBlockIndex < MAX_FONT_BLOCKS) { // // Yes - return the information from our cached copy. // *pulStart = pFont->pBlocks[usBlockIndex].ulStartCodepoint; return(pFont->pBlocks[usBlockIndex].ulNumCodepoints); } else { // // We don't have the block header cached so read it from the // SDCard. First move the file pointer to the expected position. // bRetcode = FATWrapperFontBlockHeaderGet(&pFont->sFile, &sBlock, usBlockIndex); if(bRetcode) { *pulStart = sBlock.ulStartCodepoint; return(sBlock.ulNumCodepoints); } else { UARTprintf("Error reading block header!\n"); } } // // If we get here, something horrible happened so return a failure. // *pulStart = 0; return(0); }