/**************************************************************************/ /*!
* @brief The function returns lenght of text
* @param pText - pointer to text
* @return count of characters in text
* @note None.
*******************************************************************************/
D4D_INDEX D4D_GetTextLength(D4D_TCHAR* pText)
{
D4D_INDEX cnt = 0;
D4D_TCHAR* pTextInt;
if(pText == NULL)
return 0;
pTextInt = D4D_GetInternalStringPointer(pText);
#if D4D_EXTSRC_TEXT_ENABLE != D4D_FALSE
if(pTextInt == NULL)
cnt = (D4D_INDEX)d4d_extsrcLocale.D4DLOCALE_GetTranslateStrLength(pText);
else
#endif
{
while (*pTextInt++)
cnt++;
}
return cnt;
}
/**************************************************************************/ /*!
* @brief The function returns width of text in pixels
* @param ix - font index
* @param pText - pointer to text
* @return width of text in pixels
* @note The function find out the width of string printed in given font.
*******************************************************************************/
D4D_COOR D4D_GetTextWidth(D4D_FONT ix, D4D_TCHAR* pText){
D4D_COOR width = 0;
D4D_TCHAR* pTextInt;
if(pText == NULL)
return 0;
pTextInt = D4D_GetInternalStringPointer(pText);
#if D4D_EXTSRC_TEXT_ENABLE != D4D_FALSE
if(pTextInt == NULL)
{
D4D_INDEX charCnt = 0;
D4D_INDEX charOff = 0;
D4D_INDEX charCntTmp;
do
{
charOff += charCnt;
charCnt = (D4D_INDEX)d4d_extsrcLocale.D4DLOCALE_TranslateStr(pText, (D4D_TCHAR*)d4d_extsrcBuffer, charOff, D4D_EXTSRC_BUFF_SIZE);
for(charCntTmp = 0; charCntTmp < charCnt; charCntTmp++)
width += D4D_GetCharWidth(ix, ((D4D_TCHAR*)d4d_extsrcBuffer)[charCntTmp]);
}while(charCnt == D4D_EXTSRC_BUFF_SIZE);
}else
#endif
{
while(*(pTextInt) != 0)
width += D4D_GetCharWidth(ix, *pTextInt++);
}
return width;
}
/**************************************************************//*!
*
* Print the String in ASCII in simple format up to 8 columns
*
******************************************************************/
void D4D_LCD_PrintStr(D4D_PRINT_DESC* p_StrDes)
{
D4D_INDEX str_len, ch_ix;
D4D_COOR orig_x = p_StrDes->x;
D4D_COOR base_y, base_x;
D4D_FONT_TYPE* pFontType = (D4D_FONT_TYPE*)p_StrDes->pFontType;
D4D_FONT_DESCRIPTOR* pFontDescriptor = (D4D_FONT_DESCRIPTOR*)(pFontType->pFontDescriptor);
const D4D_TCHAR pLongTextEnd[] = D4D_DEFSTR("...");
D4D_BOOL longText = D4D_FALSE;
D4D_COOR tmp_MaxLen = p_StrDes->maxWidth;
D4D_COOR longTextLen;
D4D_TCHAR* pTextInt;
// check if fontdescriptor exist and check the font scale value
if((pFontDescriptor == NULL) || (pFontType->scale.width == 0) || (pFontType->scale.height == 0))
return;
// long strings restriction
if(tmp_MaxLen)
{
// check if the text fits into enabled width
D4D_STRING tmpString;
D4D_COOR tmp_txtLen;
tmpString.pText = p_StrDes->pText;
tmpString.buffSize = 0;
tmpString.fontId = p_StrDes->pFontType->ix_font;
tmpString.printLen = p_StrDes->textLength;
tmpString.printOff = p_StrDes->textOffset;
tmp_txtLen = D4D_GetTextBuffWidthTab(&tmpString, p_StrDes->pTab);
if(p_StrDes->pTab)
{
if(tmp_txtLen > p_StrDes->pTab->tabOffset)
tmp_txtLen -= p_StrDes->pTab->tabOffset;
else
return;
}
longTextLen = D4D_GetTextWidth(tmpString.fontId, (D4D_TCHAR*)pLongTextEnd);
if(tmp_txtLen > p_StrDes->maxWidth)
{
if(tmp_txtLen < longTextLen)
return;
tmp_MaxLen -= longTextLen;
longText = D4D_TRUE;
}
}
pTextInt = D4D_GetInternalStringPointer(p_StrDes->pText);
#if D4D_EXTSRC_TEXT_ENABLE != D4D_FALSE
if(pTextInt == NULL)
{
D4D_INDEX charCnt = 0;
D4D_INDEX charOff = p_StrDes->textOffset;
D4D_INDEX charCntTmp;
do
{
charOff += charCnt;
charCnt = (D4D_INDEX)d4d_extsrcLocale.D4DLOCALE_TranslateStr(p_StrDes->pText, (D4D_TCHAR*)d4d_extsrcBuffer, charOff, D4D_EXTSRC_BUFF_SIZE);
// get the lenght of string
str_len = charCnt;
if(p_StrDes->textLength)
if(str_len > p_StrDes->textLength)
str_len = p_StrDes->textLength;
str_len += (charOff - 1);
for(charCntTmp = 0; charCntTmp < charCnt; charCntTmp++)
{
if((!((D4D_TCHAR*)d4d_extsrcBuffer)[charCntTmp]) || (str_len < (charCntTmp + charOff)))
{
charCnt = 0;
break;
}
if(longText)
{
D4D_COOR tmp_Len;
tmp_Len = D4D_GetCharWidth(p_StrDes->pFontType->ix_font, ((D4D_TCHAR*)d4d_extsrcBuffer)[charCntTmp]);
if(tmp_MaxLen - tmp_Len <= 0)
{
charCnt = 0;
break;
}
tmp_MaxLen -= tmp_Len;
}
p_StrDes->x += D4D_LCD_PrintChr(((D4D_TCHAR*)d4d_extsrcBuffer)[charCntTmp], p_StrDes); // print the char and automatically update the coordintaion of next char
}
}while(charCnt == D4D_EXTSRC_BUFF_SIZE);
}else
#endif
{
pTextInt = &pTextInt[p_StrDes->textOffset];
// get the lenght of string
str_len = D4D_GetTextLength(pTextInt);
if(p_StrDes->textLength)
if(str_len > p_StrDes->textLength)
str_len = p_StrDes->textLength;
// Draw the text
for (ch_ix=0; ch_ix<str_len; ++ch_ix) // For each character in the string
{
if(longText)
{
D4D_COOR tmp_Len;
tmp_Len = D4D_GetCharWidth(p_StrDes->pFontType->ix_font, *pTextInt);
if(tmp_MaxLen - tmp_Len <= 0)
{
break;
}
tmp_MaxLen -= tmp_Len;
}
p_StrDes->x += D4D_LCD_PrintChr(*pTextInt++, p_StrDes); // print the char and automatically update the coordintaion of next char
}
}
if(longText)
{
ch_ix=0;
while(pLongTextEnd[ch_ix])
p_StrDes->x += D4D_LCD_PrintChr(pLongTextEnd[ch_ix++], p_StrDes); // print the char and automatically update the coordintaion of next char
if(!(p_StrDes->properties & D4D_FNT_PRTY_TRANSPARENT_MASK))
D4D_FillRectXY(p_StrDes->x, p_StrDes->y, (D4D_COOR)(orig_x + p_StrDes->maxWidth - 1), (D4D_COOR)(p_StrDes->y + D4D_GetFontHeight(p_StrDes->pFontType->ix_font) - 1), p_StrDes->colorBack);
}
// Draw the Underline option
switch(p_StrDes->properties & D4D_FNT_PRTY_UNDERLINE_MASK)
{
case D4D_FNT_PRTY_UNDERLINE_LINE_MASK: // Draw the full line
base_y = (D4D_COOR)(p_StrDes->y + pFontDescriptor->charBaseLine * pFontType->scale.height);
base_x = p_StrDes->x;
D4D_FillRectXY(orig_x, base_y, (D4D_COOR)(base_x - 1), (D4D_COOR)(base_y + pFontType->scale.height - 1), p_StrDes->colorText);
break;
case D4D_FNT_PRTY_UNDERLINE_DOT_MASK: // Draw the dot line
base_y = (D4D_COOR)(p_StrDes->y + pFontDescriptor->charBaseLine * pFontType->scale.height);
ch_ix = 0;
for(base_x = orig_x; base_x < p_StrDes->x; base_x += pFontType->scale.height)
{
if(++ch_ix % 2)
D4D_FillRectXY(base_x, base_y, (D4D_COOR)(base_x + pFontType->scale.width - 1), (D4D_COOR)(base_y + pFontType->scale.height - 1), p_StrDes->colorText);
}
break;
default:
break;
}
// Draw the Strike Through option
if(p_StrDes->properties & D4D_FNT_PRTY_STRIKETHROUGH_MASK)
{
Byte line_cnt = (Byte)((p_StrDes->properties & D4D_FNT_PRTY_STRIKETHROUGH_MASK) >> D4D_FNT_PRTY_STRIKETHROUGH_SHIFT);
base_y = (D4D_COOR)(p_StrDes->y + (pFontDescriptor->charBaseLine - (pFontDescriptor->charSize / 3)) * pFontType->scale.height);
base_x = p_StrDes->x;
// Draw Strike Through line as many as specified by parameter
while(line_cnt)
{
D4D_FillRectXY(orig_x, base_y, (D4D_COOR)(base_x - 1), (D4D_COOR)(base_y - 1), p_StrDes->colorText);
base_y -=2;
line_cnt--;
}
}
/**************************************************************************/ /*!
* @brief The function find out the maximal text length that fits to maximal pixel width
* @param pString - pointer to full string descriptor (MUST be full filled)
* @param maxWidth - maximal width where the text should fits
* @return length of text that's fits to given maximal width
* @note None.
*******************************************************************************/
D4D_INDEX D4D_GetTextMaxLength(D4D_STRING* pString, D4D_COOR maxWidth)
{
D4D_TCHAR* pText;
D4D_COOR width;
D4D_INDEX cnt = 0;
D4D_TCHAR* pTextInt;
if(pString == NULL)
return 0;
pText = pString->pText;
if(pText == NULL)
return 0;
pTextInt = D4D_GetInternalStringPointer(pText);
#if D4D_EXTSRC_TEXT_ENABLE != D4D_FALSE
if(pTextInt == NULL)
{
D4D_INDEX charCnt = 0;
D4D_INDEX charOff = pString->printOff;
D4D_INDEX charCntTmp;
do
{
charOff += charCnt;
charCnt = (D4D_INDEX)d4d_extsrcLocale.D4DLOCALE_TranslateStr(pText, (D4D_TCHAR*)d4d_extsrcBuffer, charOff, D4D_EXTSRC_BUFF_SIZE);
for(charCntTmp = 0; charCntTmp < charCnt; charCntTmp++)
{
if(((D4D_TCHAR*)d4d_extsrcBuffer)[charCntTmp] == 0)
return cnt;
if(cnt >= pString->printLen)
return cnt;
width = D4D_GetCharWidth(pString->fontId, *pText);
if(width > maxWidth)
return cnt;
maxWidth -= width;
cnt++;
}
}while(charCnt == D4D_EXTSRC_BUFF_SIZE);
}
else
#endif
{
pTextInt += pString->printOff;
while(*pTextInt != 0)
{
if(cnt >= pString->printLen)
break;
width = D4D_GetCharWidth(pString->fontId, *pTextInt);
if(width > maxWidth)
break;
maxWidth -= width;
pTextInt++;
cnt++;
}
}
return cnt;
}
/**************************************************************************/ /*!
* @brief The function returns width of text in pixels, also with tab table
* @param text_buffer - pointer to full string descriptor (MUST be full filled)
* @param pTab - pointer to teb table
* @return width of text in pixels
* @note The function find out the width of string printed with all specified properties in string descriptor.
*******************************************************************************/
D4D_COOR D4D_GetTextBuffWidthTab(D4D_STRING* text_buffer, D4D_TAB* pTab){
D4D_COOR width = 0;
D4D_COOR tab;
D4D_INDEX char_ix = 0;
D4D_TCHAR* pText = text_buffer->pText;
D4D_TCHAR* pTextInt;
if(pText == NULL)
return 0;
pTextInt = D4D_GetInternalStringPointer(pText);
#if D4D_EXTSRC_TEXT_ENABLE != D4D_FALSE
if(pTextInt == NULL)
{
D4D_INDEX charCnt = 0;
D4D_INDEX charOff = text_buffer->printOff;
D4D_INDEX charCntTmp;
do
{
charOff += charCnt;
charCnt = (D4D_INDEX)d4d_extsrcLocale.D4DLOCALE_TranslateStr(pText, (D4D_TCHAR*)d4d_extsrcBuffer, charOff, D4D_EXTSRC_BUFF_SIZE);
for(charCntTmp = 0; charCntTmp < charCnt; charCntTmp++)
{
if(++char_ix > text_buffer->printLen)
return width;
if(((D4D_TCHAR*)d4d_extsrcBuffer)[charCntTmp] == '\t')
{
tab = D4D_GetNextTab(pTab, width);
if(tab)
{
width = (D4D_COOR)(tab - (pTab->tabOffset));
continue;
}
}
width += D4D_GetCharWidth(text_buffer->fontId, ((D4D_TCHAR*)d4d_extsrcBuffer)[charCntTmp]);
}
}while(charCnt == D4D_EXTSRC_BUFF_SIZE);
}else
#endif
{
pTextInt += text_buffer->printOff;
while(*pTextInt != 0)
{
if(++char_ix > text_buffer->printLen)
break;
if(*pTextInt == '\t')
{
tab = D4D_GetNextTab(pTab, width);
if(tab)
{
width = (D4D_COOR)(tab - (pTab->tabOffset));
pTextInt++;
continue;
}
}
width += D4D_GetCharWidth(text_buffer->fontId, *pTextInt);
pTextInt++;
}
}
return width;
}
static D4D_BOOL D4D_TextBoxGetCharsToLine(D4D_TXTBX_WORD_DESC* wordDesc)
{
D4D_TCHAR* pTmpWord = wordDesc->pWord;
D4D_COOR len, tmp_len;
len = wordDesc->pixLen;
wordDesc->pixLen = 0;
wordDesc->newLine = D4D_FALSE;
wordDesc->charCnt = 0;
if(pTmpWord == NULL)
return D4D_FALSE;
pTmpWord = D4D_GetInternalStringPointer(pTmpWord);
#if D4D_EXTSRC_TEXT_ENABLE != D4D_FALSE
if(pTmpWord == NULL)
{
D4D_INDEX charCnt = 0;
D4D_INDEX charOff = wordDesc->offset;
D4D_INDEX charCntTmp;
do
{
charOff += charCnt;
charCnt = (D4D_INDEX)d4d_extsrcLocale.D4DLOCALE_TranslateStr(pTmpWord, (D4D_TCHAR*)d4d_extsrcBuffer, charOff, D4D_EXTSRC_BUFF_SIZE);
for(charCntTmp = 0; charCntTmp < charCnt; charCntTmp++)
{
tmp_len = D4D_GetCharWidth(wordDesc->fnt, ((D4D_TCHAR*)d4d_extsrcBuffer)[charCntTmp]);
// normal char
if((wordDesc->pixLen + tmp_len) > len)
return D4D_TRUE;
wordDesc->pixLen += tmp_len;
wordDesc->charCnt++; // increament the one processed char
}
}while(charCnt == D4D_EXTSRC_BUFF_SIZE);
}
else
#endif
{
pTmpWord += wordDesc->offset;
while(*pTmpWord) // check if the tested strings isn't on end
{
tmp_len = D4D_GetCharWidth(wordDesc->fnt, *pTmpWord);
// normal char
if((wordDesc->pixLen + tmp_len) > len)
return D4D_TRUE;
wordDesc->pixLen += tmp_len;
wordDesc->charCnt++; // increament the one processed char
pTmpWord++; // increment WORD pointer to next char
}
}
return D4D_TRUE;
}
static D4D_BOOL D4D_TextBoxGetWordSpec(D4D_TXTBX_WORD_DESC* wordDesc)
{
D4D_TCHAR* pTmpWord = wordDesc->pWord;
D4D_TCHAR* pTextInt;
wordDesc->newLine = D4D_FALSE;
wordDesc->pixLen = 0;
wordDesc->charCnt = 0;
if(pTmpWord == NULL)
return D4D_TRUE;
pTextInt = D4D_GetInternalStringPointer(pTmpWord);
#if D4D_EXTSRC_TEXT_ENABLE != D4D_FALSE
if(pTextInt == NULL)
{
D4D_INDEX charCnt = 0;
D4D_INDEX charOff = wordDesc->offset;
D4D_INDEX charCntTmp;
(D4D_INDEX)d4d_extsrcLocale.D4DLOCALE_TranslateStr(pTmpWord, (D4D_TCHAR*)d4d_extsrcBuffer, wordDesc->offset, 1);
if(!((D4D_TCHAR*)d4d_extsrcBuffer)[0])
return D4D_TRUE;
do
{
charOff += charCnt;
charCnt = (D4D_INDEX)d4d_extsrcLocale.D4DLOCALE_TranslateStr(pTmpWord, (D4D_TCHAR*)d4d_extsrcBuffer, charOff, D4D_EXTSRC_BUFF_SIZE);
for(charCntTmp = 0; charCntTmp < charCnt; charCntTmp++)
{
if(D4D_TextBoxGetWordSpecInt(((D4D_TCHAR*)d4d_extsrcBuffer)[charCntTmp], wordDesc))
{
wordDesc->charCnt++; // increament the one processed char
}else
return D4D_FALSE;
}
}while(charCnt == D4D_EXTSRC_BUFF_SIZE);
}
else
#endif
{
pTextInt += wordDesc->offset;
if(! *pTextInt)
return D4D_TRUE;
while(*pTextInt) // check if the tested strings isn't on end
{
if(D4D_TextBoxGetWordSpecInt(*pTextInt, wordDesc))
{
wordDesc->charCnt++; // increament the one processed char
pTextInt++; // increment WORD pointer to next char
}else
return D4D_FALSE;
}
}
return D4D_FALSE;
}
