int FontResource::getCharWidth(uint c) const {
byte *charData = getCharData(c);
if (charData)
return charData[0];
else
return 0;
}
byte *FontResource::getChar(uint c) const {
byte *charData = getCharData(c);
if (charData)
return charData + 1;
else
return NULL;
}
void GfxFontFromResource::draw(uint16 chr, int16 top, int16 left, byte color, bool greyedOutput) {
// Make sure we're comparing against the correct dimensions
// If the font we're drawing is already upscaled, make sure we use the full screen width/height
uint16 screenWidth = _screen->fontIsUpscaled() ? _screen->getDisplayWidth() : _screen->getWidth();
uint16 screenHeight = _screen->fontIsUpscaled() ? _screen->getDisplayHeight() : _screen->getHeight();
int charWidth = MIN<int>(getCharWidth(chr), screenWidth - left);
int charHeight = MIN<int>(getCharHeight(chr), screenHeight - top);
byte b = 0, mask = 0xFF;
int y = 0;
int16 greyedTop = top;
byte *pIn = getCharData(chr);
for (int i = 0; i < charHeight; i++, y++) {
if (greyedOutput)
mask = ((greyedTop++) % 2) ? 0xAA : 0x55;
for (int done = 0; done < charWidth; done++) {
if ((done & 7) == 0) // fetching next data byte
b = *(pIn++) & mask;
if (b & 0x80) // if MSB is set - paint it
_screen->putFontPixel(top, left + done, y, color);
b = b << 1;
}
}
}
void scrolling(void) {
snooze(scrolldelay);
uint8_t board_offset;
for (board_offset = 0; board_offset < (8*numboards); board_offset = board_offset + 8) {
if (board_offset) delay(10); // interframe delay, per data sheet
spi_start();
uint8_t r;
for (r=0; r < 8; r++) {
//produce all the columns of one row
int o = ho; // start with the global offset
char *txt = t;
uint8_t w = getCharWidth(*txt);
uint8_t b = getCharData(*txt, r, ho);
uint8_t c = 0;
while (c < (board_offset + 8)) {
if (o <= w) { // any bits left?
if (c >= board_offset) {
spi_put((b & 0x80) ? fgcolor : bgcolor);
}
c++; // next column
o++; // ... using next bit of this one
b = (b << 1); // ...teed up right here
} else { // advance to next char
if (*txt) ++txt;
w = getCharWidth(*txt);
b = getCharData(*txt, r, 0);
o = 0;
}
}
}
spi_end();
}
// update offset and char for next frame
if (++ho > getCharWidth(*t)) {
ho = 0;
if (*t) ++t; // on to the next char
}
if (!(*t)) {
snooze(0); // cancel the iso-snooze above
set_state(dwell);
}
}
XMLInt32 ParserForXMLSchema::decodeEscaped() {
// XML Schema doesn't support an escaped "$"
if (getState() != REGX_T_BACKSOLIDUS)
ThrowXMLwithMemMgr(ParseException,XMLExcepts::Parser_Next1, getMemoryManager());
XMLInt32 ch = getCharData();
switch (ch) {
case chLatin_n:
ch = chLF;
break;
case chLatin_r:
ch = chCR;
break;
case chLatin_t:
ch = chHTab;
break;
case chBackSlash:
case chPipe:
case chPeriod:
case chCaret:
case chDash:
case chQuestion:
case chAsterisk:
case chPlus:
case chOpenCurly:
case chCloseCurly:
case chOpenParen:
case chCloseParen:
case chOpenSquare:
case chCloseSquare:
break;
default:
{
XMLCh chString[] = {chBackSlash, (XMLCh)ch, chNull};
ThrowXMLwithMemMgr1(ParseException,XMLExcepts::Parser_Process2, chString, getMemoryManager());
}
}
return ch;
}
void GfxFontFromResource::drawToBuffer(uint16 chr, int16 top, int16 left, byte color, bool greyedOutput, byte *buffer, int16 bufWidth, int16 bufHeight) {
int charWidth = MIN<int>(getCharWidth(chr), bufWidth - left);
int charHeight = MIN<int>(getCharHeight(chr), bufHeight - top);
byte b = 0, mask = 0xFF;
int y = 0;
int16 greyedTop = top;
byte *pIn = getCharData(chr);
for (int i = 0; i < charHeight; i++, y++) {
if (greyedOutput)
mask = ((greyedTop++) % 2) ? 0xAA : 0x55;
for (int done = 0; done < charWidth; done++) {
if ((done & 7) == 0) // fetching next data byte
b = *(pIn++) & mask;
if (b & 0x80) { // if MSB is set - paint it
int offset = (top + y) * bufWidth + (left + done);
buffer[offset] = color;
}
b = b << 1;
}
}
}
RangeToken* RegxParser::parseCharacterClass(const bool useNRange) {
setParseContext(regexParserStateInBrackets);
processNext();
RangeToken* tok = 0;
bool isNRange = false;
if (getState() == REGX_T_CHAR && getCharData() == chCaret) {
isNRange = true;
processNext();
}
tok = fTokenFactory->createRange();
parserState type;
bool firstLoop = true;
bool wasDecoded;
while ( (type = getState()) != REGX_T_EOF) {
wasDecoded = false;
// single range | from-to-range | subtraction
if (type == REGX_T_CHAR && getCharData() == chCloseSquare && !firstLoop)
break;
XMLInt32 ch = getCharData();
bool end = false;
if (type == REGX_T_BACKSOLIDUS) {
switch(ch) {
case chLatin_d:
case chLatin_D:
case chLatin_w:
case chLatin_W:
case chLatin_s:
case chLatin_S:
case chLatin_i:
case chLatin_I:
case chLatin_c:
case chLatin_C:
{
tok->mergeRanges(getTokenForShorthand(ch));
end = true;
}
break;
case chLatin_p:
case chLatin_P:
{
RangeToken* tok2 = processBacksolidus_pP(ch);
if (tok2 == 0) {
ThrowXMLwithMemMgr(ParseException,XMLExcepts::Parser_Atom5, getMemoryManager());
}
tok->mergeRanges(tok2);
end = true;
}
break;
case chDash:
wasDecoded = true;
// fall thru to default.
default:
ch = decodeEscaped();
}
} // end if REGX_T_BACKSOLIDUS
else if (type == REGX_T_XMLSCHEMA_CC_SUBTRACTION && !firstLoop) {
if (isNRange)
{
tok = RangeToken::complementRanges(tok, fTokenFactory, fMemoryManager);
isNRange=false;
}
RangeToken* rangeTok = parseCharacterClass(false);
tok->subtractRanges(rangeTok);
if (getState() != REGX_T_CHAR || getCharData() != chCloseSquare) {
ThrowXMLwithMemMgr(ParseException,XMLExcepts::Parser_CC5, getMemoryManager());
}
break;
} // end if REGX_T_XMLSCHEMA...
processNext();
if (!end) {
if (type == REGX_T_CHAR
&& (ch == chOpenSquare
|| ch == chCloseSquare
|| (ch == chDash && getCharData() == chCloseSquare && firstLoop))) {
// if regex = [-] then invalid...
// '[', ']', '-' not allowed and should be escaped
XMLCh chStr[] = { ch, chNull };
ThrowXMLwithMemMgr2(ParseException,XMLExcepts::Parser_CC6, chStr, chStr, getMemoryManager());
}
if (ch == chDash && getCharData() == chDash && getState() != REGX_T_BACKSOLIDUS && !wasDecoded) {
XMLCh chStr[] = { ch, chNull };
ThrowXMLwithMemMgr2(ParseException,XMLExcepts::Parser_CC6, chStr, chStr, getMemoryManager());
}
if (getState() != REGX_T_CHAR || getCharData() != chDash) {
tok->addRange(ch, ch);
}
else {
processNext();
if ((type = getState()) == REGX_T_EOF)
ThrowXMLwithMemMgr(ParseException,XMLExcepts::Parser_CC2, getMemoryManager());
if (type == REGX_T_CHAR && getCharData() == chCloseSquare) {
tok->addRange(ch, ch);
tok->addRange(chDash, chDash);
}
else if (type == REGX_T_XMLSCHEMA_CC_SUBTRACTION) {
static const XMLCh dashStr[] = { chDash, chNull};
ThrowXMLwithMemMgr2(ParseException, XMLExcepts::Parser_CC6, dashStr, dashStr, getMemoryManager());
}
else {
XMLInt32 rangeEnd = getCharData();
XMLCh rangeEndStr[] = { rangeEnd, chNull };
if (type == REGX_T_CHAR) {
if (rangeEnd == chOpenSquare
|| rangeEnd == chCloseSquare
|| rangeEnd == chDash)
// '[', ']', '-' not allowed and should be escaped
ThrowXMLwithMemMgr2(ParseException, XMLExcepts::Parser_CC6, rangeEndStr, rangeEndStr, getMemoryManager());
}
else if (type == REGX_T_BACKSOLIDUS) {
rangeEnd = decodeEscaped();
}
processNext();
if (ch > rangeEnd) {
XMLCh chStr[] = { ch, chNull };
ThrowXMLwithMemMgr2(ParseException,XMLExcepts::Parser_Ope3, rangeEndStr, chStr, getMemoryManager());
}
tok->addRange(ch, rangeEnd);
}
}
}
firstLoop = false;
}
if (getState() == REGX_T_EOF)
ThrowXMLwithMemMgr(ParseException,XMLExcepts::Parser_CC2, getMemoryManager());
if (isNRange)
{
if(useNRange)
tok->setTokenType(Token::T_NRANGE);
else
tok = RangeToken::complementRanges(tok, fTokenFactory, fMemoryManager);
}
tok->sortRanges();
tok->compactRanges();
// If the case-insensitive option is enabled, we need to
// have the new RangeToken instance build its internal
// case-insensitive RangeToken.
if (RegularExpression::isSet(fOptions, RegularExpression::IGNORE_CASE))
{
tok->getCaseInsensitiveToken(fTokenFactory);
}
setParseContext(regexParserStateNormal);
processNext();
return tok;
}
