void ASNLexer::LookupTag(void)
{
while ( true ) {
char c = Char();
switch ( c ) {
case '\r':
case '\n':
LexerWarning("unclosed tag", 11);
return;
case 0:
if ( Eof() ) {
LexerWarning("unclosed tag", 12);
return;
}
AddChar();
LexerWarning("illegal character in tag", 13);
break;
case ']':
AddChar();
return;
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
// case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
AddChar();
break;
default:
AddChar();
LexerWarning("illegal character in tag", 14);
break;
}
}
}
void CUICustomEdit::AddLetter(char c)
{
if (m_bNumbersOnly)
{
if ((c >= '0' && c<='9'))
AddChar(c);
return;
}
if(m_bShift)
{
switch(c) {
case '1': c='!'; break;
case '2': c='@'; break;
case '3': c='#'; break;
case '4': c='$'; break;
case '5': c='%'; break;
case '6': c='^'; break;
case '7': c='&'; break;
case '8': c='*'; break;
case '9': c='('; break;
case '0': c=')'; break;
default:
c = c-'a';
c = c+'A';
}
}
AddChar(c);
}
PUBLIC char *AddString(char * String)
{
NewString();
while (*String) {
AddChar( *String );
String++;
}
AddChar( '\0' );
return TopOfTable;
}
TToken ASNLexer::LookupNumber(void)
{
while ( IsDigit(Char()) ) {
AddChar();
}
char c = Char();
if (c == '.' || c == 'e' || c == 'E' || c == '-' || c == '+') {
AddChar();
LookupNumber();
return T_DOUBLE;
}
return T_NUMBER;
}
TToken ASNLexer::LookupBinHexString(void)
{
TToken token = T_BINARY_STRING;
while ( true ) {
char c = Char();
switch ( c ) {
case '\r':
case '\n':
LexerWarning("unclosed bit string", 5);
return token;
case 0:
if ( Eof() ) {
LexerWarning("unclosed bit string", 6);
return token;
}
AddChar();
LexerWarning("illegal character in bit string", 7);
break;
case '0':
case '1':
AddChar();
break;
case '2': case '3': case '4': case '5': case '6': case '7': case '8':
case '9': case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
AddChar();
token = T_HEXADECIMAL_STRING;
break;
case '\'':
switch ( Char(1) ) {
case 'B':
AddChars(2);
if ( token != T_BINARY_STRING )
LexerWarning("binary string contains hexadecimal digits", 8);
return T_BINARY_STRING;
case 'H':
AddChars(2);
return T_HEXADECIMAL_STRING;
default:
AddChar();
LexerWarning("unknown type of bit string", 9);
return token;
}
default:
AddChar();
LexerWarning("illegal character in bit string", 10);
break;
}
}
}
void PrintChars(const char* txt, int test)
{
/* int i;
int colour;
sscanf(txt, "%d", &colour);
unsigned short* ptr = (unsigned short*)g_Screen;
for (i=0;i<5000;i++)
{
*ptr = colour & 0xffff;
ptr++;
}
*/
while (*txt)
{
if (test)
{
AddChar(*txt);
}
else
{
PutCharOnScreen(*txt);
}
txt++;
}
}
void CChatMsgBuffer::AddSring(char *txt)
{
int TextLen = strlen(txt);
for(int Cpt = 0; Cpt < TextLen; Cpt++)
AddChar(txt[Cpt]);
}
CString CNumEncoder::EncodeToString()
{
CString Ret = "";
for(int i=0; i<m_Numbers.GetSize(); i++)
{
CString Temp;
Temp.Format("%d", m_Numbers[i]);
AddChar(Ret, (char)Temp.GetLength());
for(int j=0; j<Temp.GetLength(); j++)
{
AddChar(Ret, Temp.GetAt(j) - '0');
}
}
return Ret;
}
void ASNLexer::LookupIdentifier(void)
{
while ( true ) {
char c = Char();
if ( IsAlNum(c) )
AddChar();
else if ( c == '-' ) {
if ( IsAlNum(Char(1)) )
AddChars(2);
else {
if ( AllowIDsEndingWithMinus() )
AddChar();
return;
}
}
else
return;
}
}
//FreeTypeCharData
FreeTypeCharData::FreeTypeCharData(FreeTypeCharData** ppCh, FreeTypeCharData** ppGl, WCHAR wch, UINT glyphindex, int width, int mru, int gdiWidth, int AAMode)
: m_ppSelfGlyph(ppGl), m_glyphindex(glyphindex), m_width(width)
, m_glyph(NULL), m_glyphMono(NULL), m_bmpSize(0), m_bmpMonoSize(0)
, FreeTypeMruCounter(mru), m_gdiWidth(gdiWidth), m_AAMode(AAMode)
{
g_pFTEngine->AddMemUsedObj(this);
AddChar(ppCh);
#ifdef _DEBUG
m_wch = wch;
#endif
}
EXC_TYPE IStrlBuilder::Repeat (const TCHAR tch, const UINT32 ulNumReps)
{
for (UINT32 rIndex=0; rIndex < ulNumReps; rIndex++)
{
EXC_TYPE exc=AddChar(tch);
if (exc != EOK)
return exc;
}
return EOK;
}
TToken ASNLexer::LookupToken(void)
{
char c = Char();
switch ( c ) {
case ':':
if ( Char(1) == ':' && Char(2) == '=' ) {
StartToken();
AddChars(3);
return T_DEFINE;
}
return T_SYMBOL;
case '-':
case '+':
if ( IsDigit(Char(1)) ) {
StartToken();
AddChar();
return LookupNumber();
}
return T_SYMBOL;
case '\"':
StartToken();
AddChar();
StartString();
LookupString();
return T_STRING;
case '\'':
StartToken();
AddChar();
return LookupBinHexString();
case '[':
StartToken();
AddChar();
LookupTag();
return T_TAG;
default:
if ( IsDigit(c) ) {
StartToken();
AddChar();
return LookupNumber();
}
else if ( c >= 'a' && c <= 'z' ) {
StartToken();
AddChar();
LookupIdentifier();
return T_IDENTIFIER;
}
else if ( c >= 'A' && c <= 'Z' ) {
StartToken();
AddChar();
LookupIdentifier();
return LookupKeyword();
}
return T_SYMBOL;
}
}
/*-----------------------------------------------------------------------------
* pack a number tlv
*-----------------------------------------------------------------------------*/
int AddNumTlv(char **ppCur, int *piLeftLen, NumTLV *pstNumTlv)
{
uint16_t wType = 0, wLen = 0;
if(ppCur == NULL || piLeftLen == NULL || pstNumTlv == NULL )
{
return -1;
}
wType = pstNumTlv->wType;
wLen = pstNumTlv->wLen;
if(wType == 0 || wLen == 0 || wLen > MAX_NUMBER_TLV_LEN)
{
return -2;
}
if((AddWord(ppCur, piLeftLen, wType)) != 0)
return -3;
if((AddWord(ppCur, piLeftLen, wLen)) != 0)
return -4;
if(wLen == CHAR_LEN)
{
if((AddChar(ppCur, piLeftLen, pstNumTlv->stValue.cValue)) != 0)
return -5;
}
else if(wLen == WORD_LEN)
{
if((AddWord(ppCur, piLeftLen, pstNumTlv->stValue.wValue)) != 0)
return -6;
}
else if(wLen == DWORD_LEN)
{
if((AddDWord(ppCur, piLeftLen, pstNumTlv->stValue.dwValue)) != 0)
return -7;
}
else if(wLen == DDWORD_LEN)
{
if((AddDDWord(ppCur, piLeftLen, pstNumTlv->stValue.ddwValue)) != 0)
return -8;
}
else
{
printf("GetNumTlvValue error. wLen = %d\n", wLen);
return -9;
}
return 0;
}
void ASNLexer::LookupString(void)
{
while ( true ) {
char c = Char();
switch ( c ) {
case '\r':
case '\n':
LexerWarning("unclosed string", 1);
return;
case 0:
if ( Eof() ) {
LexerWarning("unclosed string", 2);
return;
}
LexerWarning("illegal character in string: \\0", 3);
AddStringChar(c);
AddChar();
break;
case '\"':
if ( Char(1) != '\"' ) {
AddChar();
return;
}
AddChars(2);
break;
default:
if ( c < ' ' && c > '\0' ) {
LexerWarning("illegal character in string: \\...", 4);
}
else {
AddStringChar(c);
}
AddChar();
break;
}
}
}
EXC_TYPE IStrlBuilder::AddPadNum (const UINT32 ulVal,
const UINT32 ulVLen, /* may NOT be 0 */
const TCHAR padCh, /* may NOT be '\0' */
const BOOLEAN fLeftPad)
{
if ((0 == ulVLen) || (_T('\0') == padCh))
return EPARAM;
TCHAR szV[MAX_DWORD_DISPLAY_LENGTH+2]=_T("");
UINT32 ulVLL=::dword_to_argument(ulVal, szV), vIdx=ulVLL;
if (ulVLL > ulVLen)
return EOVERFLOW;
EXC_TYPE exc=EOK;
if (fLeftPad)
{
/* add padding */
for (vIdx=ulVLL; vIdx < ulVLen; vIdx++)
if ((exc=AddChar(padCh)) != EOK)
return exc;
if ((exc=AddChars(szV, ulVLL)) != EOK)
return exc;
}
else /* right pad */
{
if ((exc=AddChars(szV, ulVLL)) != EOK)
return exc;
/* add padding */
for (vIdx=ulVLL; vIdx < ulVLen; vIdx++)
if ((exc=AddChar(padCh)) != EOK)
return exc;
}
return EOK;
}
int TEXTEDITBOX::ProcFunction(PASSPROCVARS Params){
TCHAR Char;
//
switch(Params.uMsg){
case WM_PAINT:
RestoreFonts();
Pass.DDFront->Restore();
Pass.DDBack->Restore();
this->EditBoxSurface->Restore();
DDReLoadBitmap(this->EditBoxSurface, BMP_TEXTEDITBOX);
this->StorageSurface->Restore();
break;
case WM_CHAR:
switch(Params.wParam){
case 0x08: /* backspace */
DeleteChar();
break;
case 0x0A: /* linefeed */
case 0x0D: /* carriage return */
Info=TEBI_DONE;
break;
case 0x1B: /* escape */
case 0x09: /* tab */
break;
default:
//normal character:
Char=(TCHAR) Params.wParam;
AddChar(Char);
break;
}
break;
case WM_KEYDOWN:
///put it in the box.
switch(Params.wParam){
case VK_RETURN:
break;
case VK_ESCAPE:
break;
case VK_LEFT:
break;
case VK_RIGHT:
break;
}
break;
}
UpdateBox();
return 0;
}
EXC_TYPE IStrlBuilder::AddTime (const UINT8 bHour,
const UINT8 bMinute,
const UINT8 bSecond)
{
EXC_TYPE exc=EOK;
if ((bHour >= 24) || (bMinute >= 60) || (bSecond >= 60))
return EINVALIDTIME;
if ((exc=AddPadNum(bHour, 2)) != EOK)
return exc;
if ((exc=AddChar(_T(':'))) != EOK)
return exc;
if ((exc=AddPadNum(bMinute, 2)) != EOK)
return exc;
if ((exc=AddChar(_T(':'))) != EOK)
return exc;
if ((exc=AddPadNum(bSecond, 2)) != EOK)
return exc;
return EOK;
}
void FontString::UpdateMesh()
{
if(m_MeshNeedsUpdate)
{
VertexList Vertices;
IndexList Indices;
for(int i = 0; i < m_Content.size(); i++)
{
AddChar(m_Content[i], &Vertices, &Indices);
}
m_Mesh->LoadMesh(Vertices, Indices);
m_MeshNeedsUpdate = false;
}
}
EXC_TYPE IStrlBuilder::AddGMTOffset (const int iTimeZone) /* (-1) == use internal */
{
BYTE hrsOffset=0, minsOffset=0;
int itz=(((-1) == iTimeZone) ? _timezone : iTimeZone);
EXC_TYPE exc=::GetTimeZoneComponents(itz, &hrsOffset, &minsOffset);
if (exc != EOK)
return exc;
if ((exc=AddChar(((itz < 0) ? _T('+') : _T('-')))) != EOK)
return exc;
if ((exc=AddPadNum(hrsOffset, 2)) != EOK)
return exc;
if ((exc=AddPadNum(minsOffset, 2)) != EOK)
return exc;
return EOK;
}
void DeleteCharBackward(HIMC hIMC,WORD wParam)
{
if(wConversionMode & CONVERSION_MODE_PHRASETOCHAR){
MakeResultString(hIMC,FALSE);
}
else if( wConversionMode & CONVERSION_MODE_I ||
wConversionMode & CONVERSION_MODE_U ||
wConversionMode & CONVERSION_MODE_V ) {
LPINPUTCONTEXT lpIMC;
LPCANDIDATEINFO lpCandInfo;
LPCANDIDATELIST lpCandList;
LPCOMPOSITIONSTRING lpCompStr;
GENEMSG GnMsg;
LPTSTR lpStr;
lpIMC = ImmLockIMC(hIMC);
lpCandInfo = (LPCANDIDATEINFO)ImmLockIMCC(lpIMC->hCandInfo);
lpCandList = (LPCANDIDATELIST)((LPSTR)lpCandInfo + lpCandInfo->dwOffset[0]);
lpCompStr = (LPCOMPOSITIONSTRING)ImmLockIMCC(lpIMC->hCompStr);
if( !lpCandList->dwCount ) MakeResultString(hIMC,FALSE);
else{
lpCandList->dwCount = 0;
lpStr = GETLPCOMPSTR(lpCompStr);
lpStr = CharPrev(lpStr,lpStr + _tcslen(lpStr));
*lpStr= _T('\0');
lpStr = ((LPMYCOMPSTR)lpCompStr)->FreePYComp.szPaintCompStr;
lpStr = CharPrev(lpStr,lpStr + _tcslen(lpStr));
*lpStr= _T('\0');
GnMsg.msg = WM_IME_COMPOSITION;
GnMsg.wParam = 0;
GnMsg.lParam = GCS_COMPSTR;
GenerateMessage(hIMC, lpdwCurTransKey,(LPGENEMSG)&GnMsg);
}
ImmUnlockIMCC(lpIMC->hCompStr);
ImmUnlockIMCC(lpIMC->hCandInfo);
ImmUnlockIMC(hIMC);
}
else AddChar(hIMC,wParam,EDIT_BACK);
return;
}
CodePage::CodePage()
{
SET_SHARED_PTR(codepage);
memset(m_pages, 0, sizeof(m_pages));
memset(m_codes, 0, sizeof(m_codes));
m_num = 0;
// rozsireni tabulky o zakladni ascii znaky
for (wchar_t c = ' '; c <= 'z';c++)
AddChar(c);
GetExec()->Register("specialchars", CodePage::c_specialchars, NULL, "Register next unicode chars.");
//Register("quit",c_quit,NULL,"quit program");
//Register("quit!",c_fquit,NULL,"force quit");
//Register("help",c_help,NULL);
//Register("list",c_list,NULL,"List all commands.");
}
BOOL CCmdParse::ProcessCmdLine()
{
State = e_start;
Previous = State; //may be used in the future
m_pCurrent = &m_szParseString[0];
memset(m_Token,'\0',512);
while(State != e_end)
{
switch(State)
{
//
case e_error:
return FALSE;
default:
AddChar();
}
}
return TRUE;
}
void LVRtfParser::OnControlWord( const char * control, int param, bool asterisk )
{
const rtf_control_word * cw = findControlWord( control );
if ( cw ) {
switch ( cw->type ) {
case CWT_CHAR:
{
lChar16 ch = (lChar16)cw->index;
if ( ch==13 ) {
// TODO: end of paragraph
CommitText();
m_stack.getDestination()->OnAction(LVRtfDestination::RA_PARA);
} else {
AddChar(ch);
}
}
break;
case CWT_STYLE:
break;
case CWT_ACT:
CommitText();
m_stack.getDestination()->OnAction(cw->index);
break;
case CWT_TPROP:
CommitText();
if ( param == PARAM_VALUE_NONE )
param = cw->defvalue;
m_stack.getDestination()->OnTblProp( cw->index, param );
break;
case CWT_DEST:
#ifdef LOG_RTF_PARSING
CRLog::trace("DEST: \\%s", cw->name);
#endif
switch ( cw->index ) {
case dest_upr:
m_stack.set( pi_skip_ansi, 1 );
break;
case dest_ud:
m_stack.set( pi_skip_ansi, 0 );
break;
case dest_fonttbl:
m_stack.set( new LVRtfNullDestination(*this) );
break;
case dest_stylesheet:
m_stack.set( new LVRtfNullDestination(*this) );
break;
case dest_footnote:
m_stack.set( new LVRtfNullDestination(*this) );
break;
case dest_info:
case dest_header:
case dest_footer:
case dest_colortbl:
m_stack.set( new LVRtfNullDestination(*this) );
break;
case dest_pict:
m_stack.set( new LVRtfPictDestination(*this) );
break;
}
break;
case CWT_IPROP:
CommitText();
if ( param == PARAM_VALUE_NONE )
param = cw->defvalue;
#ifdef LOG_RTF_PARSING
CRLog::trace("PROP: \\%s %d", cw->name, param);
#endif
m_stack.set( cw->index, param );
break;
}
} else {
#ifdef LOG_RTF_PARSING
CRLog::trace("CW: %s\\%s %d", asterisk?"\\*":"", control, param==PARAM_VALUE_NONE ? 0 : param);
#endif
if ( asterisk ) {
// ignore text after unknown keyword
m_stack.set( new LVRtfNullDestination(*this) );
#ifdef LOG_RTF_PARSING
CRLog::trace("Ignoring unknown destination %s !!!", control );
#endif
}
}
}
const T_CHAR * Peek()
{
AddChar(0);
used--;
return data;
}
void AddString(const T_CHAR * z)
{
while(*z) {AddChar(*z);z++;}
}
static unsigned MechMisc( unsigned select, unsigned parm )
{
long value;
unsigned result = 0;
mad_type_info mti;
switch( select ) {
case 0:
ExprAddrDepth += parm;
result = ExprAddrDepth;
break;
case 1:
if( _IsOn( SW_EXPR_IS_CALL ) && ExprAddrDepth == 0 ) {
result = TRUE;
} else {
result = FALSE;
}
break;
case 2:
SkipCount += parm;
break;
case 3:
result = SkipCount;
break;
case 4:
//never called
break;
case 5:
if( ScanSavePtr >= MAX_SCANSAVE_PTRS )
Error( ERR_INTERNAL, LIT( ERR_TOO_MANY_SCANSAVE ) );
CurrScan[ScanSavePtr++] = ScanPos();
break;
case 6:
if( ScanSavePtr <= 0 ) Error( ERR_INTERNAL, LIT( ERR_TOO_MANY_SCANRESTORE ) );
ReScan( CurrScan[--ScanSavePtr] );
break;
case 7:
if( ScanSavePtr <= 0 ) Error( ERR_INTERNAL, LIT( ERR_TOO_MANY_SCANRESTORE ) );
--ScanSavePtr;
break;
case 8:
if( parm ) { /* start scan string */
scan_string = TRUE;
ReScan( ScanPos() );
} else { /* end scan string */
scan_string = FALSE;
ReScan( ScanPos() );
}
break;
case 9:
ReScan( ScanPos() + (int)parm );
break;
case 10:
AddChar();
break;
case 11:
AddCEscapeChar();
break;
case 12:
AddActualChar( '\0' );
break;
case 13:
ScanCCharNum = parm;
break;
case 14:
if( NestedCallLevel == MAX_NESTED_CALL - 1 ) {
Error( ERR_NONE, LIT( ERR_TOO_MANY_CALLS ) );
} else {
PgmStackUsage[ ++NestedCallLevel ] = 0;
}
break;
case 15:
RValue( ExprSP );
ConvertTo( ExprSP, TK_INTEGER, TM_SIGNED, 4 );
value = U32FetchTrunc( ExprSP->v.uint ) - 1;
PopEntry();
if( ExprSP->info.kind == TK_STRING ) {
if( value < 0 || value >= ExprSP->info.size ) {
Error( ERR_NONE, LIT( ERR_BAD_SUBSTRING_INDEX ) );
}
LocationAdd( &ExprSP->v.string.loc, value*8 );
ExprSP->info.size -= value;
ExprSP->v.string.ss_offset = value;
} else {
Error( ERR_NONE, LIT( ERR_ILL_TYPE ) );
}
break;
case 16:
RValue( ExprSP );
ConvertTo( ExprSP, TK_INTEGER, TM_SIGNED, 4 );
value = U32FetchTrunc( ExprSP->v.sint ) - 1;
PopEntry();
if( ExprSP->info.kind == TK_STRING ) {
value -= ExprSP->v.string.ss_offset;
if( value < 0 || value >= ExprSP->info.size ) {
Error( ERR_NONE, LIT( ERR_BAD_SUBSTRING_INDEX ) );
}
ExprSP->info.size = value;
} else {
Error( ERR_NONE, LIT( ERR_ILL_TYPE ) );
}
break;
case 17:
EvalSubstring = parm;
if( parm ) ExprSP->v.string.ss_offset = 0;
break;
case 18:
result = EvalSubstring;
break;
case 19:
FreePgmStack( TRUE );
break;
case 20:
switch( parm ) { // nyi - begin temp
case SSL_CASE_SENSITIVE:
_SwitchOn( SW_CASE_SENSITIVE );
break;
case SSL_SIDE_EFFECT:
_SwitchOn( SW_SIDE_EFFECT );
break;
//case SSL_32_BIT:
// _SwitchOn( SW_32_BIT );
// break;
}
break;
case 21:
switch( parm ) {
case SSL_CASE_SENSITIVE:
_SwitchOff( SW_CASE_SENSITIVE );
break;
case SSL_SIDE_EFFECT:
_SwitchOff( SW_SIDE_EFFECT );
break;
//case SSL_32_BIT:
// _SwitchOff( SW_32_BIT );
// break;
}
break;
case 22:
switch( parm ) {
case SSL_CASE_SENSITIVE:
result = _IsOn( SW_CASE_SENSITIVE );
break;
case SSL_SIDE_EFFECT:
result = _IsOn( SW_SIDE_EFFECT );
break;
case SSL_32_BIT:
GetMADTypeDefault( MTK_INTEGER, &mti );
result = (mti.b.bits >= 32);
break;
}
break;
case 23: // nyi - end temp
MarkArrayOrder( parm );
break;
case 24:
StartSubscript();
break;
case 25:
AddSubscript();
break;
case 26:
EndSubscript();
break;
}
return( result );
}
bool CUICustomEdit::KeyPressed(int dik)
{
xr_map<u32, char>::iterator it;
char out_me = 0;
bool bChanged = false;
switch(dik)
{
case DIK_LEFT:
case DIKEYBOARD_LEFT:
m_lines.DecCursorPos();
break;
case DIK_RIGHT:
case DIKEYBOARD_RIGHT:
m_lines.IncCursorPos();
break;
case DIK_LSHIFT:
case DIK_RSHIFT:
m_bShift = true;
break;
case DIK_ESCAPE:
if (xr_strlen(GetText()) != 0)
{
SetText("");
bChanged = true;
}
else
{
GetParent()->SetKeyboardCapture(this, false);
m_bInputFocus = false;
m_iKeyPressAndHold = 0;
};
break;
case DIK_RETURN:
case DIK_NUMPADENTER:
GetParent()->SetKeyboardCapture(this, false);
m_bInputFocus = false;
m_iKeyPressAndHold = 0;
GetMessageTarget()->SendMessage(this,EDIT_TEXT_COMMIT,NULL);
break;
case DIK_BACKSPACE:
m_lines.DelLeftChar();
bChanged = true;
break;
case DIK_DELETE:
case DIKEYBOARD_DELETE:
m_lines.DelChar();
bChanged = true;
break;
case DIK_SPACE:
out_me = ' '; break;
case DIK_LBRACKET:
out_me = m_bShift ? '{' : '['; break;
case DIK_RBRACKET:
out_me = m_bShift ? '}' : ']'; break;
case DIK_SEMICOLON:
out_me = m_bShift ? ':' : ';'; break;
case DIK_APOSTROPHE:
out_me = m_bShift ? '"' : '\''; break;
case DIK_BACKSLASH:
out_me = m_bShift ? '|' : '\\'; break;
case DIK_SLASH:
out_me = m_bShift ? '?' : '/'; break;
case DIK_COMMA:
out_me = m_bShift ? '<' : ','; break;
case DIK_PERIOD:
out_me = m_bShift ? '>' : '.'; break;
case DIK_MINUS:
out_me = m_bShift ? '_' : '-'; break;
case DIK_EQUALS:
out_me = m_bShift ? '+' : '='; break;
default:
it = gs_DIK2CHR.find(dik);
//нажата клавиша с буквой
if (gs_DIK2CHR.end() != it){
AddLetter((*it).second);
bChanged = true;
}
break;
}
if (m_bNumbersOnly)
{
if (strstr(m_lines.GetText(), "."))
return true;
if (('.' == out_me) && m_bFloatNumbers){
AddChar(out_me);
bChanged = true;
}
}
else
if(out_me){
AddChar(out_me);
bChanged = true;
}
if(bChanged)
GetMessageTarget()->SendMessage(this,EDIT_TEXT_CHANGED,NULL);
return true;
}
void CRenderer::DrawText( const MGuiRendFont* fnt, const char_t* text, int32 x, int32 y, uint32 flags, const MGuiFormatTag tags[], uint32 ntags )
{
int32 dx, dy, lineX, lineY;
uint32 c, ntag = 0, idx = 0;
colour_t lineColour, defaultColour;
register const char_t* s;
const MGuiFormatTag* tag = NULL;
const CFont* font = (const CFont*)fnt;
if ( fnt == NULL || text == NULL ) return;
lineStatus = LINE_IDLE;
if ( renderTexture == NULL || renderTexture != font->texture )
{
Flush();
renderTexture = font->texture;
}
IncreaseZPlane();
UpdateVertexFormat( true );
renderFont = font;
defaultColour.hex = drawColour.hex;
if ( tags && ntags > 0 ) tag = &tags[ntag];
dx = x; lineX = dx;
dy = y; lineY = dy;
for ( s = text; *s; ++s, ++idx )
{
c = *(uchar_t*)s;
// Process possible format tags for this index
if ( tag && tag->index == idx )
{
ProcessTag( tag );
ProcessUnderline( font, dx, dy, lineX, lineY, lineColour );
if ( ++ntag < ntags ) tag = &tags[ntag];
else tag = NULL;
}
if ( c < font->first_char || c > font->last_char )
{
continue;
}
else
{
dx += AddChar( c - font->first_char, dx, dy, flags );
}
}
Flush();
// Finish the underline in case the end tag was missing
if ( lineStatus == LINE_DRAWING )
{
lineStatus = LINE_DRAW;
ProcessUnderline( font, dx, dy, lineX, lineY, lineColour );
}
// Reset back to default colour if the end tag was missing.
if ( drawColour.hex != defaultColour.hex )
{
SetDrawColour( &defaultColour );
}
UpdateVertexFormat( false );
renderTexture = NULL;
renderFont = NULL;
}
void LVRtfParser::AddChar8( lUInt8 ch )
{
lChar16 ch16 = m_stack.byteToUnicode(ch);
if ( ch16 )
AddChar( ch16 );
}
/// parses input stream
bool LVRtfParser::Parse()
{
//m_conv_table = GetCharsetByte2UnicodeTable( L"cp1251" );
bool errorFlag = false;
m_callback->OnStart(this);
// make fb2 document structure
m_callback->OnTagOpen( NULL, L"?xml" );
m_callback->OnAttribute( NULL, L"version", L"1.0" );
m_callback->OnAttribute( NULL, L"encoding", L"utf-8" );
//m_callback->OnEncoding( GetEncodingName().c_str(), GetCharsetTable( ) );
m_callback->OnTagBody();
m_callback->OnTagClose( NULL, L"?xml" );
m_callback->OnTagOpenNoAttr( NULL, L"FictionBook" );
// DESCRIPTION
m_callback->OnTagOpenNoAttr( NULL, L"description" );
m_callback->OnTagOpenNoAttr( NULL, L"title-info" );
//
lString16 bookTitle = LVExtractFilenameWithoutExtension( getFileName() ); //m_stream->GetName();
m_callback->OnTagOpenNoAttr( NULL, L"book-title" );
if ( !bookTitle.empty() )
m_callback->OnText( bookTitle.c_str(), bookTitle.length(), 0 );
//queue.DetectBookDescription( m_callback );
m_callback->OnTagOpenNoAttr( NULL, L"title-info" );
m_callback->OnTagClose( NULL, L"description" );
// BODY
m_callback->OnTagOpenNoAttr( NULL, L"body" );
//m_callback->OnTagOpen( NULL, L"section" );
// process text
//queue.DoTextImport( m_callback );
//m_callback->OnTagClose( NULL, L"section" );
txtbuf = new lChar16[ MAX_TXT_SIZE+1 ];
txtpos = 0;
txtfstart = 0;
char cwname[33];
while ( !Eof() && !errorFlag && !m_stopped ) {
// load next portion of data if necessary
if ( m_buf_len - m_buf_pos < MIN_BUF_DATA_SIZE ) {
if ( !FillBuffer( MIN_BUF_DATA_SIZE*2 ) ) {
errorFlag = true;
break;
}
}
int len = (int)m_buf_len - (int)m_buf_pos;
// check end of file
if ( len <=0 )
break; //EOF
const lUInt8 * p = m_buf + m_buf_pos;
lUInt8 ch = *p++;
if ( ch=='{' ) {
OnBraceOpen();
m_buf_pos++;
continue;
} else if ( ch=='}' ) {
OnBraceClose();
m_buf_pos++;
continue;
}
lUInt8 ch2 = *p;
if ( ch=='\\' && *p!='\'' ) {
// control
bool asteriskFlag = false;
if ( ch2=='*' ) {
ch = *(++p);
ch2 = *(++p);
asteriskFlag = true;
}
if ( (ch2>='A' && ch2<='Z') || (ch2>='a' && ch2<='z') ) {
// control word
int cwi = 0;
do {
cwname[cwi++] = ch2;
ch2 = *++p;
} while ( ( (ch2>='A' && ch2<='Z') || (ch2>='a' && ch2<='z') ) && cwi<32 );
cwname[cwi] = 0;
int param = PARAM_VALUE_NONE;
if ( ch2==' ' ) {
p++;
} else {
if ( ch2 == '-' ) {
p++;
param = 0;
for ( ;; ) {
ch2 = *++p;
if ( ch2<'0' || ch2>'9' )
break;
param = param * 10 + (ch2-'0');
}
param = -param;
} else if ( ch2>='0' && ch2<='9' ) {
param = 0;
while ( ch2>='0' && ch2<='9' ) {
param = param * 10 + (ch2-'0');
ch2 = *++p;
}
}
if ( *p == ' ' )
p++;
}
// \uN -- unicode character
if ( cwi==1 && cwname[0]=='u' ) {
AddChar( (lChar16) (param & 0xFFFF) );
// if ( m_stack.getInt( pi_skip_ch_count )==0 )
// m_stack.set( pi_skip_ch_count, 1 );
} else {
// usual control word
OnControlWord( cwname, param, asteriskFlag );
}
} else {
// control char
cwname[0] = ch2;
cwname[1] = 0;
p++;
OnControlWord( cwname, PARAM_VALUE_NONE, asteriskFlag );
}
m_buf_pos += p - (m_buf + m_buf_pos);
} else {
//lChar16 txtch = 0;
if ( ch=='\\' ) {
p++;
int digit1 = charToHex( p[0] );
int digit2 = charToHex( p[1] );
p+=2;
if ( digit1>=0 && digit2>=0 ) {
AddChar8( (lChar8)((digit1 << 4) | digit2) );
} else {
AddChar('\\');
AddChar('\'');
AddChar8(digit1);
AddChar8(digit2);
p+=2;
}
} else {
if ( ch>=' ' ) {
AddChar8( ch );
} else {
// wrong char
}
}
//=======================================================
//=======================================================
m_buf_pos += p - (m_buf + m_buf_pos);
}
}
m_callback->OnStop();
delete[] txtbuf;
txtbuf = NULL;
CommitText();
m_stack.getDestination()->OnAction(LVRtfDestination::RA_SECTION);
m_callback->OnTagClose( NULL, L"body" );
m_callback->OnTagClose( NULL, L"FictionBook" );
return !errorFlag;
}
