guicharset.c

The combined demo is dedicated for S1C33L05, so DMT33L05 should be used to load and run the demo. F

/* $id: guiCharset.c V1.0 2001/11/2 */
/***************************************************************************
 *    This source code has been made available to you by EPSON on an AS-IS
 *    basis. Anyone receiving this source is licensed under EPSON
 *    copyrights to use it in any way he or she deems fit, including
 *    copying it, modifying it, compiling it, and redistributing it either
 *    with or without modifications.
 *
 *    Any person who transfers this source code or any derivative work
 *    must include the EPSON copyright notice, this paragraph, and the
 *    preceding two paragraphs in the transferred software.
 *
 *    COPYRIGHT   EPSON  CORPORATION 2001
 *    LICENSED MATERIAL  -  PROGRAM PROPERTY OF EPSON
 **************************************************************************/


/***************************************************************************
 * FILE: guiCharset.c
 * MODULE: FONT
 *
 * PURPOSE: define many char operation sets.
 *
 *
 * AUTHOR(S): ZhaoJZ
 * GROUP: GUI Group
 * DATE CREATED: 2001/11/2
 * REFERENCE DOCUMENT ID:
 * MODIFICATIONS:
 *    Date           userName          Description
 *    2001/11/2      ZhaoJZ            Create this file
 **************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include "sysGUI.h"

//#include "guiTotal.h"
#include "guiFont.h"

#include "guiCharset.h"


/*************** Common Operations for single byte charsets ******************/

T_MODULE T_WORD sb_len_first_char(T_CONST T_UBYTE *mstr, T_WORD len)
{
    if(len < 1) return 0;
    if(*mstr != '\0')  return 1;
    return 0;
}

T_MODULE T_WORD sb_char_offset(T_CONST T_UBYTE *mchar)
{
    return (T_WORD)(*mchar);
}

T_MODULE T_WORD sb_nr_chars_in_str(T_CONST T_UBYTE *mstr, T_WORD mstrlen)
{
    return mstrlen;
}

T_MODULE T_WORD sb_len_first_substr(T_CONST T_UBYTE *mstr, T_WORD mstrlen)
{
    return mstrlen;
}

T_MODULE T_WORD sb_pos_first_char(T_CONST T_UBYTE *mstr, T_WORD mstrlen)
{
    return 0;
}
T_MODULE T_CONST T_UBYTE *sb_get_next_word(
	                      T_CONST T_UBYTE *mstr,
                          T_WORD mstrlen,
                          T_GUI_WordInfo *word_info
                          )
{
    T_WORD i;

    if(mstrlen == 0) return NULL;

    word_info->len = 0;
    word_info->delimiter = '\0';
    word_info->nr_delimiters = 0;

    for(i = 0; i < mstrlen; i++)
	{
        switch(mstr[i])
		{
            case ' ':
            case '\t':
            case '\n':
            case '\r':
                if(word_info->delimiter == '\0')
				{
                    word_info->delimiter = mstr[i];
                    word_info->nr_delimiters ++;
				}
                else if(word_info->delimiter == mstr[i])
                    word_info->nr_delimiters ++;
                else
                    return mstr + word_info->len + word_info->nr_delimiters;
                break;

            default:
                if(word_info->delimiter != '\0')
                    break;

                word_info->len ++;
		}
    }

    return mstr + word_info->len + word_info->nr_delimiters;
}

/************************* ISO8859-1 Specific Operations **********************/
T_MODULE T_BOOL iso8859_1_is_this_charset(T_CONST T_UBYTE *charset)
{
    T_WORD i;
    T_BYTE name[LEN_FONT_NAME + 1];

    for(i = 0; i < LEN_FONT_NAME + 1; i++)
	{
        if(charset[i] == '\0')
            break;
        name[i] = toupper(charset[i]);
    }
    name[i] = '\0';

    if(strstr(name, "ISO") && strstr(name, "8859") && strstr(name, "1"))
        return TRUE;

    return FALSE;
}

/* define the operations of ISO8859-1 */
T_MODULE T_GUI_CharsetOps CharsetOps_iso8859_1 =
{
    256,
    1,
    1,
    FONT_CHARSET_ISO8859_1,
    {' '},
    sb_len_first_char,
    sb_char_offset,
    sb_nr_chars_in_str,
    iso8859_1_is_this_charset,
    sb_len_first_substr,
    sb_get_next_word,
    sb_pos_first_char,
};

/******************************************************************************/
/******************************************************************************/
/******************************************************************************/
/*************** Common Operations for double bytes charsets ******************/
/******************************************************************************/
/******************************************************************************/
/******************************************************************************/

#if defined(_GB_SUPPORT) | defined(_BIG5_SUPPORT) | defined(_SJIS_SUPPORT)

T_MODULE T_WORD db_nr_chars_in_str(T_CONST T_UBYTE* mstr, T_WORD mstrlen)
{
    return mstrlen >> 1;
}

T_MODULE T_CONST T_UBYTE  *db_get_next_word(T_CONST T_UBYTE* mstr, T_WORD mstrlen, T_GUI_WordInfo* word_info)
{
   if(mstrlen == 0) return NULL;
   word_info->len = 2;
   word_info->delimiter = '\0';
   word_info->nr_delimiters = 0;
   return mstr + 2;
}

#endif //defined(_GB_SUPPORT) | defined(_BIG5_SUPPORT) | defined(_SJIS_SUPPORT)

#ifdef _GB_SUPPORT
/************************* GB2312 Specific Operations ************************/
T_MODULE T_WORD gb2312_len_first_char(T_CONST T_UBYTE *mstr, T_WORD len)
{
    T_UBYTE ch1;
    T_UBYTE ch2;

    if(len < 2) return 0;

    ch1 = mstr[0];
    if(ch1 == '\0')
        return 0;

    ch2 = mstr[1];

    /* the range of GB2312 */
   if(ch1 >= 0xA1 && ch1 <= 0xFE && ch2 >= 0xA1 && ch2 <= 0xFE)
        return 2;

    return 0;
}

T_MODULE T_WORD gb2312_char_offset(T_CONST T_UBYTE *mchar)
{

    return ((mchar[0] - 0xA1) * 94 + mchar[1] - 0xA1);
}

T_MODULE T_BOOL gb2312_is_this_charset(T_CONST T_UBYTE *charset)
{
    T_WORD i;
    T_BYTE name[LEN_FONT_NAME + 1];

    for(i = 0; i < LEN_FONT_NAME + 1; i++)
	{
        if(charset[i] == '\0')
            break;
        name[i] = toupper(charset[i]);
    }
    name[i] = '\0';

    if(strstr(name, "GB") && strstr(name, "2312"))
        return TRUE;

    return FALSE;
}

T_MODULE T_WORD gb2312_len_first_substr(T_CONST T_UBYTE *mstr, T_WORD mstrlen)
{
    T_UBYTE ch1;
    T_UBYTE ch2;
    T_WORD i, left;
    T_WORD sub_len = 0;

    left = mstrlen;
    for(i = 0; i < mstrlen; i += 2)
	{
        if(left < 2) return sub_len;

        ch1 = mstr[i];
        if(ch1 == '\0') return sub_len;

        ch2 = mstr[i + 1];
        if(ch1 >= 0xA1 && ch1 <= 0xFE && ch2 >= 0xA1 && ch2 <= 0xFE)
            sub_len += 2;
        else
            return sub_len;

        left -= 2;
    }

    return sub_len;
}

T_MODULE T_WORD gb2312_pos_first_char(T_CONST T_UBYTE *mstr, T_WORD mstrlen)
{
    T_UBYTE ch1;
    T_UBYTE ch2;
    T_WORD i, left;

    i = 0;
    left = mstrlen;
    while(left)
	{
        if(left < 2) return -1;

        ch1 = mstr[i];
        if(ch1 == '\0') return -1;

        ch2 = mstr[i + 1];
        if(ch1 >= 0xA1 && ch1 <= 0xFE && ch2 >= 0xA1 && ch2 <= 0xFE)
            return i;

        i += 1;
        left -= 1;
    }

    return -1;
}

/* define the operations of GB2312 */
T_MODULE T_GUI_CharsetOps CharsetOps_gb2312 =
{
    8836,
    2,
    2,
    FONT_CHARSET_GB2312,
    {'\xA1', '\xA1'},
    gb2312_len_first_char,
    gb2312_char_offset,
    db_nr_chars_in_str,
    gb2312_is_this_charset,
    gb2312_len_first_substr,
    db_get_next_word,
    gb2312_pos_first_char,
};
#endif

//*************************************************************
//*************************************************************
//*************************************************************
//*************************************************************
//*************************************************************
//*************************************************************

#ifdef _BIG5_SUPPORT
/************************** BIG5 Specific Operations ************************/
T_MODULE T_WORD big5_len_first_char(T_CONST T_UBYTE *mstr, T_WORD len)
{
    T_UBYTE ch1;
    T_UBYTE ch2;

    if(len < 2) return 0;

    ch1 = mstr[0];
    if(ch1 == '\0')
        return 0;

    ch2 = mstr[1];

    /* the range of BIG5 */
    if(ch1 >= 0xA1 && ch1 <= 0xFE &&
            ((ch2 >=0x40 && ch2 <= 0x7E) || (ch2 >= 0xA1 && ch2 <= 0xFE)))
        return 2;

    return 0;
}

T_MODULE T_WORD big5_char_offset(T_CONST T_UBYTE *mchar)
{

    if(mchar[1] & 0x80)
        return (mchar[0] - 0xA1) * 94 + mchar[1] - 0xA1;
    else
        return 94 * 94 + (mchar[0] - 0xa1) * 63 + (mchar[1] - 0x40);
}

T_MODULE T_BOOL big5_is_this_charset(T_CONST T_UBYTE *charset)
{
    T_WORD i;
    T_BYTE name[LEN_FONT_NAME + 1];

    for(i = 0; i < LEN_FONT_NAME + 1; i++)
	{
        if(charset[i] == '\0')
            break;
        name[i] = toupper(charset[i]);
    }
    name[i] = '\0';

    if(strstr(name, "BIG5"))
        return TRUE;

    return FALSE;
}

T_MODULE T_WORD  big5_len_first_substr(T_CONST T_UBYTE *mstr, T_WORD mstrlen)
{
    T_UBYTE ch1;
    T_UBYTE ch2;
    T_WORD i, left;
    T_WORD sub_len = 0;

    left = mstrlen;
    for(i = 0; i < mstrlen; i += 2)
	{
        if(left < 2) return sub_len;

        ch1 = mstr[i];
        if(ch1 == '\0') return sub_len;

        ch2 = mstr[i + 1];
        if(ch1 >= 0xA1 && ch1 <= 0xFE &&
                ((ch2 >=0x40 && ch2 <= 0x7E) || (ch2 >= 0xA1 && ch2 <= 0xFE)))
            sub_len += 2;
        else
            return sub_len;

        left -= 2;
    }

    return sub_len;
}

T_MODULE T_WORD big5_pos_first_char(T_CONST T_UBYTE *mstr, T_WORD mstrlen)
{
    T_UBYTE ch1;
    T_UBYTE ch2;
    T_WORD i, left;

    i = 0;
    left = mstrlen;
    while(left)
	{
        if(left < 2) return -1;

        ch1 = mstr[i];
        if(ch1 == '\0') return -1;

        ch2 = mstr[i + 1];
        if(ch1 >= 0xA1 && ch1 <= 0xFE &&
                ((ch2 >=0x40 && ch2 <= 0x7E) || (ch2 >= 0xA1 && ch2 <= 0xFE)))
            return i;

        i += 1;
        left -= 1;
    }

    return -1;
}

/* define the operations of BIG5 */
T_MODULE T_GUI_CharsetOps CharsetOps_big5 =
{
    14758,
    2,
    2,
    FONT_CHARSET_BIG5,
    {'\xA1', '\x40'},
    big5_len_first_char,
    big5_char_offset,
    db_nr_chars_in_str,
    big5_is_this_charset,
    big5_len_first_substr,
    db_get_next_word,
    big5_pos_first_char,
};
#endif

//*************************************************************
//*************************************************************
//*************************************************************
//*************************************************************
//*************************************************************
//*************************************************************

#ifdef _SJIS_SUPPORT

extern const unsigned short usiFnt16tbl[6879];

int	SJIS_Serch(unsigned short usicode)
{
	int	upper,lower,a,serach,flag;

	flag=0;
	upper=6879;
	lower=0;
	serach=usicode;
	do
	{
		a=(upper+lower)/2;

		if(usiFnt16tbl[a]==serach)
		{
			flag=1;
			break;
		}
		if(usiFnt16tbl[a]>serach)
			upper=a-1;
		if(usiFnt16tbl[a]<serach)
			lower=a+1;
	}while(lower<=upper);

	if(flag==1)
		return	a;
	else
		return	0;
}

T_MODULE T_WORD SJIS_len_first_char(T_CONST T_UBYTE *mstr, T_WORD len)
{
    T_UBYTE ch1;
    T_UBYTE ch2;

    if(len < 2) 
		return 0;