system.c

好记星的控件,包括button,list,对文件操作

#include "Kernel.h"


/*************************************************************************
    Function   : 
    Description: unicode functions

    Input:
    
    Output:
      
    Return:

      DATE      AUTHOR   VERSION  REMARKS
========================================================================== 
**************************************************************************/

struct {
    UINT  ucsNum;            // number of UCS code in the convert table
    BYTE *ucs2gbk;           // address of UCS to GBK table
    BYTE *gbk2ucs;           // address of GBK to UCS table
} locTable;

void LocInitial(UINT num, void *ucs2gbk, void *gbk2ucs)
{
	locTable.gbk2ucs = gbk2ucs;
	locTable.ucs2gbk = ucs2gbk;
	locTable.ucsNum = num;
}

BOOL LocIsDBCSLeadByteEx(UINT CodePage, BYTE TestChar);
BOOL LocIsDBCSLeadByte(BYTE TestChar)
{
    return LocIsDBCSLeadByteEx(0, TestChar);
}

WORD __swap(WORD ch)
{
	return (ch>>8)+((WORD)(ch&0xFF)<<8);
}

wchar_t __gbk2ucs(WORD wChar)
{
    int highb, lowb, number;
    
	highb = LOBYTE(wChar);
    lowb = HIBYTE(wChar);

	if (highb>=0xa1 && highb<=0xa9 && lowb>=0xa1 && lowb<=0xfe){
		number = (highb-0xa1)*94 + lowb - 0xa1;
	} else if (highb>=0xb0 && highb<=0xf7 && lowb>=0xa1 && lowb<=0xfe){
        number = (highb-0xb0)*94 + lowb - 0xa1 + 846;
    } else if (highb>=0x81 && highb<=0xa0 && lowb>=0x40 && lowb<=0xfe){
        number = (highb-0x81)*190 + lowb - 0x40 + 846 + 6768;
        if(lowb > 0x7f)
            number --;
    } else if (highb>=0xaa && highb<=0xfe && lowb>=0x40 && lowb<=0xa0){
        number = (highb-0xaa)*96 + lowb - 0x40 + 846 + 6768 + 6080;
        if(lowb > 0x7f)
            number --;
    } else if (highb>=0xa8 && highb<=0xa9 && lowb>=0x40 && lowb<=0xa0){
        number = (highb-0xa8)*96 + lowb - 0x40 + 846 + 6768 + 6080 + 8160;
        if(lowb > 0x7f)
            number --;
    } else {
		number = 0;
	}

    return __swap(*(wchar_t *)(locTable.gbk2ucs + number*2));
}

int __compare(const wchar_t *ucs1, const wchar_t *ucs2)
{
	return (__swap(*ucs1)-__swap(*ucs2));
}

BOOL __ucs2gbk(wchar_t wChar, WORD *wTarget)
{
	WORD ch, *result;

	ch = __swap(wChar);
	result = (WORD *)bsearch((const void *)&ch, (const void *)locTable.ucs2gbk, 
		locTable.ucsNum, 4, (int (*)(const void*, const void*))__compare);

	if (result == 0){
		WRITE_WORD(wTarget, 0xA1B0);
		return FALSE;
	} else {
		WRITE_WORD(wTarget, result[1]);
		return TRUE;
	}
}

BOOL LocIsDBCSLeadByteEx(UINT CodePage, BYTE TestChar)
{
    if(TestChar >= 0x80){
        return TRUE;
    }
    
    return FALSE;
}

int LocDBCSToUnicode(UINT CodePage, DWORD dwFlags, const BYTE *lpMultiByteStr, int cbMultiByte, wchar_t *lpWideCharStr, int cchWideChar)
{
    int length, src_count;
    
    if (cchWideChar == 0){
        // test target length only
        length = 0;
        if (cbMultiByte == -1){
            // source string is null-end
            for(src_count=0; lpMultiByteStr[src_count]!=0; src_count++){
                if (LocIsDBCSLeadByte(lpMultiByteStr[src_count])){
                    src_count ++;     
                }
                length++;
            }
            return length+1;
        } else {
            // source string has count
            for(src_count=0; src_count<cbMultiByte; src_count++){
                if (LocIsDBCSLeadByte(lpMultiByteStr[src_count])){
                    src_count ++;     
                }
                length++;                
            }
            return length;
        }
    } else {
        // do convert
        length = 0;
        if (cbMultiByte == -1){
            // source string is null-end
            for(src_count=0; lpMultiByteStr[src_count]!=0; src_count++){
				if (length < cchWideChar){
					// space is enough
	                if (LocIsDBCSLeadByte(lpMultiByteStr[src_count])){
						WRITE_WORD(lpWideCharStr+length, __gbk2ucs((WORD)READ_WORD(lpMultiByteStr+src_count)));
	                    src_count ++;
					} else {
						WRITE_WORD(lpWideCharStr+length, (WORD)(lpMultiByteStr[src_count]));
					}
					length++;
                } else {
					// target buffer full
					return length;
				}
            }
			// append null-end
			if (length < cchWideChar){
				WRITE_WORD(lpWideCharStr+length, 0);
				length++;
			}
        } else {
            // source string has count
            for(src_count=0; src_count<cbMultiByte; src_count++){
				if (length < cchWideChar){
					// space is enough
	                if (LocIsDBCSLeadByte(lpMultiByteStr[src_count])){
						WRITE_WORD(lpWideCharStr+length, __gbk2ucs((WORD)READ_WORD(lpMultiByteStr+src_count)));
	                    src_count ++;
					} else {
						WRITE_WORD(lpWideCharStr+length, (WORD)(lpMultiByteStr[src_count]));
					}
					length++;
                } else {
					// target buffer full
					return length;
				}
            }
		}
		return length;
	}
}

int LocUnicodeToDBCS(UINT CodePage, DWORD dwFlags, const wchar_t *lpWideCharStr, int cchWideChar, BYTE *lpMultiByteStr, int cbMultiByte, const BYTE *lpDefaultChar)
{
    int length, src_count;

    if (cbMultiByte == 0){
        // test target length only
        length = 0;
        if (cchWideChar == -1){
            // source string is null-end
            for(src_count=0; READ_WORD(lpWideCharStr+src_count)!=0; src_count++){
				length++;
				if (READ_WORD(lpWideCharStr+src_count) >= 0x80){
					length++;
				}
            }
            return length+1;
        } else {
            // source string has count
            for(src_count=0; src_count<cchWideChar; src_count++){
				length++;
				if (READ_WORD(lpWideCharStr+src_count) >= 0x80){
					length++;
				}
            }
            return length;
        }
    } else {
        // do convert
        length = 0;
        if (cchWideChar == -1){
            // source string is null-end
            for(src_count=0; READ_WORD(lpWideCharStr+src_count)!=0; src_count++){
				if (length < cbMultiByte-1){
					// space is enough
					if (READ_WORD(lpWideCharStr+src_count) >= 0x80){
						if (!__ucs2gbk((WORD)READ_WORD(lpWideCharStr+src_count), (WORD *)(lpMultiByteStr+length))){
							// convert failed;
							if (lpDefaultChar){
                                WRITE_WORD(lpMultiByteStr+length, *lpDefaultChar);
							}
						}
						length += 2;
					} else {
						lpMultiByteStr[length] = *(BYTE *)(lpWideCharStr+src_count);
						length ++;
					}
                } else {
					// target buffer full
					return length;
				}
            }
			// append null-end
			if (length < cbMultiByte){
				lpMultiByteStr[length] = 0;
				length++;
			}
        } else {
            // source string has count
            for(src_count=0; src_count<cchWideChar; src_count++){
				if (length < cbMultiByte-1){
					// space is enough
					if (READ_WORD(lpWideCharStr+src_count) >= 0x80){
						if (!__ucs2gbk((WORD)READ_WORD(lpWideCharStr+src_count), (WORD *)(lpMultiByteStr+length))){
							// convert failed;
							if (lpDefaultChar){
                                WRITE_WORD(lpMultiByteStr+length, *lpDefaultChar);
							}
						}
						length += 2;
					} else {
						lpMultiByteStr[length] = *(BYTE *)(lpWideCharStr+src_count);
						length ++;
					}
                } else {
					// target buffer full
					return length;
				}
            }
		}
		return length;
	}
}