windows-server-2003/windows/feime/chs/ntabc/winabc/abc95wp.c

/*************************************************
 *  abc95wp.c                                    *
 *                                               *
 *  Copyright (C) 1995-1999 Microsoft Inc.       *
 *                                               *
 *************************************************/

#include "windows.h"
#include "winuser.h"
#include "immdev.h"
#include "abc95def.h"
#include "abcbx.h"
struct  INPT_BF kbf={40,0,{0}};  
INT_PTR WINAPI OpenDlg(HWND,UINT,WPARAM,LPARAM);
int word_select_bx(int input_char);

int word_long;
int unit_length=2;          /* single word */
int disp_tail=0;
int disp_head=0;
int group_no=24;
int current_no;

/******************************************************************
/*  CharProc(ImeChar,wParam,lParam,hIMC,lpIMC,lpImcP)             *
/*****************************************************************/
extern HWND       hCrtDlg;    
int WINAPI CharProc(ImeChar,wParam,lParam,hIMC,lpIMC,lpImcP)
WORD           ImeChar;
WPARAM         wParam;
LPARAM         lParam;
HIMC           hIMC;
LPINPUTCONTEXT lpIMC;
LPPRIVCONTEXT  lpImcP;
{
    int x;
    
    ghIMC=hIMC;   
    glpIMCP=lpImcP;
    glpIMC=lpIMC;
    TypeOfOutMsg = 0;
    waitzl_flag = 0;                                  //waitzl 3
    
    if (cap_mode){
        if(ImeChar<0x8000){                //for mouse message pass
            send_one_char(ImeChar/*wParam*/);   // changed 94/8/6
            return(0);
        }
    }

    if(lpIMC->fdwConversion&IME_CMODE_NATIVE){
        switch(kb_mode){
            case CIN_STD:                         //stand change
                if (V_Flag)
                    v_proc(ImeChar);         // V fuction
                else {
                    if (sImeG.cbx_flag==1) {    
                        if (bx_allow) {         
                            if (BX_MODE(ImeChar,wParam))  
                                return(0);    
                        } 
                    } //if (sImeG.cbx_flag)

                    STD_MODE(ImeChar);
                }
                break;

            case CIN_SDA:                         //double hit inputing
                for (x=0; x<(sizeof sda_trans)/2; x++) //Note sizeof!! 1992 2
                    sda_trans[x]=0;                                 //clear the transport buffer

                if(((!step_mode)||(step_mode==RESELECT))&&((ImeChar == 0x60)||(ImeChar == 0x27)))
                    return (STD_MODE(ImeChar));

                if (sImeG.cbx_flag==1) {              
                    if (bx_allow){
                        if (BX_MODE(ImeChar,wParam))
                            return(0);
                    } //if (bx_allow)
                } //if (sImeG.cbx_flag)

                if ((step_mode==ONINPUT)&&(I_U_Flag==1)){
                    STD_MODE(ImeChar);
                    return(0);
                }

                if ( if_zimu_or_not((BYTE)ImeChar)/*||(wParam == 0x60)*/||(wParam == 0x27) )
                {
                    if ((step_mode==START)||/*(Return==NULL)||*/(step_mode==RESELECT))
                    {
                        if (((wParam&0xdf)=='U')||((wParam&0xdf)=='I'))
                        {
                            I_U_Flag=1;
                            STD_MODE(ImeChar);
                            return(0);
                        } else {
                            I_U_Flag=0;
                        }//else...
                    }//if (step_mode....
       
                    if (!Sd_Open_flag){
                        if(KeyBoardState){
                            SdaPromptOpen=1;
                            tran_data(
                                0,              
                                ghIMC,
                                Sd_Open_flag);
                        }//if Key
                    }//if (Sd_Open_flag)
                }//if (if_zimu_...

                if ((wParam==VK_BACK)&&(step_mode==ONINPUT)
                    &&(Return==NULL)&&(!Sd_Open_flag)){
                    if(KeyBoardState){
                        SdaPromptOpen=1;
                        tran_data(
                            0,              
                            ghIMC,
                            Sd_Open_flag);
                    }
                }//if (wParam)


                sda_proc(ImeChar, (LPWORD)sda_trans, step_mode, ghIMC);         //change the key into standed

                if (sda_trans[0]==0xff)      //change error or input more than 40 chars
                    break;

                if (sda_trans[0]==0xf0){                        //if free the dialog?

                    if(KeyBoardState){
                        tran_data(
                            2,              
                            ghIMC,
                            Sd_Open_flag);
                    }//if key

                    SdaPromptOpen=0;
                    sda_trans[0]=sda_trans[1];
                    sda_trans[1]=0;
                }

                x=0;                                                            //chinese spelling
                while (sda_trans[x]){
                    if (wait_flag && (sda_trans[x]=='h'))     //waitzl 4
                    waitzl_flag = 1;                
                    STD_MODE(sda_trans[x++]);
                }
                break;
        }
   }else
        send_one_char(ImeChar/*wParam*/);

   return (0);
     
}


/****************************************************************
v_proc():       produce the V fuction
*****************************************************************/
int WINAPI v_proc(input_char)
WORD input_char;
{
    int i, n;

    n=0;

    if (V_Flag==1) {
        switch (input_char) {
            case '0':
            case VK_BACK:
                 cls_inpt_bf(0);
                 step_mode = START;                                                           
                 V_Flag = 0;
                 return(1);
         }
    }

    if ((if_number_or_not((BYTE)input_char)) && (V_Flag!=2)){ 
        input_char &= 0x000f;           //get the QUMA
        for (i=1; i<=94; i++){          //get WEIMA
           if (input_char==2){
               if (i==1)  i=17;
               if (i==67) i=69;
               if (i==79) i=81;
           }
           out_svw[n++]=input_char+0xa0;                                  
           out_svw[n++]=i+0xa0;
        }

        group_no=94;
        if (input_char==2)  group_no=72;
        unit_length=2;
        current_no=0;
        disp_tail=0;
        V_Flag=0;
        msg_type=2;                       //94/8/22
        fmt_transfer();
        SetToIMC(ghIMC,(LPSTR)&out_svw,(WORD)group_no,(WORD)(unit_length+0x1000));                              
        move_result();
        prompt_disp();
        word_back_flag=0x55;                //93,9,4
        step_mode=SELECT;
    } //if (if_number_or_not)
    else {
        V_Flag=2;
        step_mode=ONINPUT;
        STD_MODE(input_char);
    }

    return (1);

}

int ReDrawSdaKB(hIMC, KbIndex, ShowOp)
HIMC hIMC;
DWORD KbIndex;
DWORD ShowOp;
{
//return 0;
if (KbIndex)                    // if not PC KB
    return 0;
if (kb_mode != CIN_SDA)
    return 0;            // if not SDA mode
if (ShowOp==SW_HIDE)  
    return 0;            // if SW_SHOW....

if (SdaInst){
    tran_data(
                       0x5678,              //Return,
                       ghIMC,//hWnd,
                       Sd_Open_flag);
    return 1;}
 return 0;
}

void WINAPI DispModeEx()  
{
    cls_inpt_bf(0);
    step_mode=START;
}

/****************************************************************
    FUNCTION: disp_mode(hW)
    PORPUSE: display the mode item at the input window.
*****************************************************************/
void WINAPI DispMode(HIMC hIMC)
{
    LPINPUTCONTEXT   lpIMC;
    LPPRIVCONTEXT    lpImcP;
    UINT             fdwConversion; 

    if (!hIMC)
        return;
    lpIMC =(LPINPUTCONTEXT)ImmLockIMC(hIMC);
    if (!lpIMC)
        return;
    lpImcP =(LPPRIVCONTEXT)ImmLockIMCC(lpIMC->hPrivate);
    if (!lpImcP)
        return;

    DispModeEx();                    //zl#3(hW);

    if (SdaInst&&(kb_mode!=CIN_SDA)){

        Sd_Open_flag=0;
        SdaPromptOpen=0;
        SdaInst=0;
  
    }
    if ((kb_mode==CIN_SDA)&&(!SdaInst)) {

        SdaInst = 1;   // The ABCSDA.DLL is Load In.
       
    }  
    ImmUnlockIMCC(lpIMC->hPrivate);
    ImmUnlockIMC(hIMC);
}






void WINAPI DispSpecChar(c,n)
int c,n;
{
   int i;
   for (i=now_cs;i<n+now_cs;i++)
    InputBuffer[i]=(BYTE)c;
    ImeSetCompositionString(ghIMC,SCS_SETSTR,NULL,0,
                  &InputBuffer,now_cs+i);


}

//////////////////////////////////////////////////////////////////////////



void WINAPI show_char(string,count)
unsigned char *string;
int count;
{

    int i;
    BOOL fdwImeMsgKeep;

    if(count==0) {
      ImeSetCompositionString(ghIMC,SCS_SETSTR,NULL,0,
                  &InputBuffer,now_cs);
      return ; }


    for(i=0; i<count; i++)
        InputBuffer[now_cs+i]=string[i];
    now_cs+=count;
    if (!(wait_flag | waitzl_flag )){              //waitzl 5

    ImeSetCompositionString(ghIMC,SCS_SETSTR,NULL,0,
                  &InputBuffer,now_cs);
        }

}


/******************************************************
disp_jiyi(): display the word "jiyi" in the windows
*******************************************************/
void WINAPI disp_jiyi(xxx)
HANDLE xxx;
{
}


/*********************************************************************
PROMPT_DISP(): display the result of changing.
**********************************************************************/
void WINAPI prompt_disp()
{

    int i;

    pass_word=0;

    disp_head=disp_tail;


    n=0;
    for(i=0; i<now.fmt_group; i++){

         disp_tail++;

        if (disp_tail>=group_no){
            pass_word=1;
            if (disp_head==0)
             pass_word=2;
            break;}
       }//for (i=...

   if (pass_word<1){
           pass_word=3;
           if (disp_head==0)
           pass_word=4;
         }


 SetToIMC(ghIMC,NULL,(WORD)pass_word,(WORD)disp_head);

}


/****************************************************
 cls_prompt
*****************************************************/
int WINAPI cls_prompt()
{
   int i;


    for (i=0;i<sizeof InputBuffer;i++) InputBuffer[i]=0x20;   //Clear the display buffer.



    now_cs = 0;
    //DispSpecChar((BYTE)0x20,sizeof InputBuffer);

    cs_p(0);

    SetCloseCompWinMsg(0);
    cls_prompt_only();   

    return 0; 

}

int WINAPI cls_prompt_only(){
   int i;
   LPINPUTCONTEXT       lpIMC;
   LPPRIVCONTEXT   lpImcP;
    

    if (!ghIMC) return (0); // The IMC must be a valid one.
   
    lpIMC = (LPINPUTCONTEXT)ImmLockIMC(ghIMC);
    if(!lpIMC)  return 0; 
  
  
    lpImcP = (LPPRIVCONTEXT)ImmLockIMCC(lpIMC->hPrivate);
   
    if ( lpImcP != NULL )
        lpImcP->fdwImeMsg = (lpImcP->fdwImeMsg | MSG_CLOSE_CANDIDATE) &
                            ~(MSG_OPEN_CANDIDATE);
    
    ImmUnlockIMCC(lpIMC->hPrivate);
    ImmUnlockIMC(ghIMC);

    return 0; 
}

                      
int WINAPI SetCloseCompWinMsg(int ClsFlag)
{
   LPINPUTCONTEXT       lpIMC;
   LPPRIVCONTEXT   lpImcP;
    

    if (!ghIMC) return (0); // The IMC must be a valid one.
    lpIMC = (LPINPUTCONTEXT)ImmLockIMC(ghIMC);
    if(!lpIMC)  return 0; 
  
    lpImcP = (LPPRIVCONTEXT)ImmLockIMCC(lpIMC->hPrivate);
    if (!ClsFlag )
    {
        if ( lpImcP != NULL )
            lpImcP->fdwImeMsg = (lpImcP->fdwImeMsg | MSG_END_COMPOSITION ) &
                                ~(MSG_COMPOSITION) ;
    }
    

    ImmUnlockIMCC(lpIMC->hPrivate);
    ImmUnlockIMC(ghIMC);

    return 0; 
}




void WINAPI ABCstrnset(bufferd,value,n)
LPSTR bufferd;
BYTE value;
{
  int i;
  for (i=0; i<n; i++) bufferd[i]=value;
  return;
}

LPSTR WINAPI ABCstrstr(str1,str2)
LPSTR str1,str2;
{
 int i,m,n,j,pos;
 m=lstrlen(str1);
 n=lstrlen(str2);
 if(!n) return str1;

 pos=0xffff0;
 for(i=0;i<m-n; i++){
     pos=i;
    for(j=0;j<n;j++) {
       if (str1[i+j]!=str2[j])
          { pos=0xffff0;break;}}
    if (pos!=0xffff0) break;
    }
 if (pos==0xffff0) return NULL;
 return str1+pos;
 }
          

/*****************************************************
back_a_space(x): do a BACKSPACE command
******************************************************/
int WINAPI back_a_space(x)
int x;
{

    if (x<=0){
         x=0;
         MessageBeep(0);}
    else{
        x--;
        InputBuffer[x]=' ';
        cs_p(x);
    }
    return(x);
}


/******************************************************
cs_p
*******************************************************/
int WINAPI cs_p(x)
int x;
{
        int xx,yy,zz,kk,i;
        now_cs=x;

        cur_hibit=1;
        hDC=GetDC(hInputWnd);
        kk=(WORD)(GetText32(hDC, InputBuffer, x))
                    +CUR_START_X;
        cur_start_ps=(WORD)(GetText32(hDC, InputBuffer,cur_start_count ))
                    +CUR_START_X;
        zz=kk-cur_start_ps;

        if (x<cur_start_count){
         cur_start_count=(WORD)x;
         now_cs_dot=CUR_START_X;
        ReleaseDC(hInputWnd,hDC);
         UpdateCompCur(hInputWnd);
        cur_hibit=0;
        return 0;}

        if (zz>=(CUR_START_X+(lpImeL->rcCompText.right-4))){
            xx=CUR_START_X;
            for (i =now_cs; i>0; i--)
            { yy=GetText32(hDC, &InputBuffer[i-1], 1);
            if ( (xx+yy) >= (CUR_START_X+(lpImeL->rcCompText.right-4)))
              break;
            else xx+=yy;
            }                                                                                                        
          cur_start_count=(WORD)i;

         // Adgust for Chines Word Display

            kk=0;
            for (i=0; i<cur_start_count; i++){
              if (InputBuffer[i]>0xa0){
                  kk++;
                  kk&=1;
                  } else
                    kk=0;}
            if (kk){
                xx=xx- GetText32(hDC, &InputBuffer[cur_start_count], 1);
                cur_start_count++;
                }

          cur_start_ps=(WORD)GetText32(hDC, &InputBuffer[0], i);
           now_cs_dot=xx;
        ReleaseDC(hInputWnd,hDC);
        UpdateCompCur(hInputWnd);
        cur_hibit=0;
        return 0;
        }

        cur_hibit=0;
        ReleaseDC(hInputWnd,hDC);

        if (zz<(CUR_START_X+(lpImeL->rcCompText.right-4))){
            now_cs_dot=kk-cur_start_ps;
                    DrawInputCur();
                    }
        return 0;

}
/********************************************************************
  Function:DrawInputCur
********************************************************************/
void WINAPI DrawInputCur()
{
 

    HDC OldDC;
    if (!hInputWnd) return;

    if ((WORD)now_cs_dot!=old_curx)
    {
           if (cur_flag)
           {
            hDC=GetDC(hInputWnd);
            OldDC=SelectObject(hMemoryDC,cur_h);
            BitBlt(hDC,old_curx+lpImeL->rcCompText.left,
              lpImeL->rcCompText.top+3,
               CUR_W,CUR_H,hMemoryDC,0,0,SRCINVERT);
            SelectObject(hMemoryDC,OldDC);
            ReleaseDC(hInputWnd,hDC);
            cur_flag=!cur_flag;
           }
           old_curx=(WORD)now_cs_dot;
    }
    hDC=GetDC(hInputWnd);
    OldDC=SelectObject(hMemoryDC,cur_h);
    BitBlt(hDC,now_cs_dot+lpImeL->rcCompText.left,
          lpImeL->rcCompText.top+3,
          CUR_W,CUR_H,hMemoryDC,0,0,SRCINVERT);
        SelectObject(hMemoryDC,OldDC);
    ReleaseDC(hInputWnd,hDC);
    cur_flag=!cur_flag;

    return;
}//#0

/************************************************************
UpdateUser(): if the user.rem has changed, clear the tmmr.rem_area
        and read the user.rem's index once again.
*************************************************************/
void WINAPI UpdateUser()
{
// 94/4/16      HANDLE hd;
    int hd;
    int i;
    WORD op_count;
    OFSTRUCT ofs;


    if (UpdateFlag) {               //increase the user.rem
        for (i=0; i<0x200; i++)          //1993.3
            tmmr.rem_area[i] = 0;
        last_item_name=0;               //clear the date in memory flag
        UpdateFlag = 0;

        hd = OpenFile (user_lib, &ofs, OF_READ);      //1993.4.15
        if (hd==-1)
            err_exit_proc(jiyi_wenjian_cuo);
        _llseek(hd,0xa000l,0);
        op_count=(WORD)_lread(hd,&kzk_ndx,NDX_REAL_LENGTH);
        if (op_count!=NDX_REAL_LENGTH)
            err_exit_proc(jiyi_wenjian_cuo);
        _lclose(hd);
        }
}




//##!!extern void AddExtLib();


///////////////////////////////////////////////////////////////////////////
//             STD_MODE
//      Deels with stdandard Chinese Pinyin input with some written_stroke
//         attributes when neccerry.
//
//////////////////////////////////////////////////////////////////////////

int WINAPI STD_MODE(input_char)
WORD input_char;
{
  int leibie,input_char_type,i;
  sImeG.InbxProc = 0;
  wait_flag=0;
  if (input_char==BACKWORD_KEY)
        return(backword_proc());
  if (input_char==FORWORD_KEY){
     if ((step_mode!=ONINPUT)&&(group_no>1))
        step_mode=SELECT;
        return(0);}

  switch(step_mode){             //step_mode indicate the input step
                 // step_mode take this value:
                 //  START=0  first input pinyin
                 //  SELECT=1 can select/cansel the result
                 //  RESELECT=2 use FORCE SELECT KEY
                 //  ONINPUT=3 just in inputing step
    case SELECT:
        if ((input_char==VK_HOME*0x100)||
            (input_char==VK_END*0x100)||
            (input_char==VK_PRIOR*0x100)||
            (input_char==VK_NEXT*0x100)){
                word_select(input_char);
                break;}

        if (input_char>=0x8000)
            input_char-=0x8000;

        if ((input_char==VK_SPACE)||(input_char==VK_RETURN)){
           if(!out_result(0))
                step_mode=RESELECT;             //92/12/14 SZ
            break;
            }

        if (input_char==VK_ESCAPE){
            cls_inpt_bf(0);
            step_mode=START;
            break;
            }

        if (input_char==VK_BACK){
             if (word_back_flag!=0x55)
                del_and_reconvert();
            break;
            }

        if (if_zimu_or_not((BYTE)input_char)){
            wait_flag=1;
            while(out_result(0));
            step_mode=START;
            }
        else{
            word_select(input_char);
            break;
            }

    case RESELECT:
    case START:

        if (input_char >= 0x8000){
            input_char -= 0x8000;
            if ( word_select(input_char) == 1 )
                return(0);
            else
                return(send_one_char(input_char));
            }//if (input_char)

        else{
            if (if_first_key(input_char)){
                if (input_char=='v')
                V_Flag = 1;
                else {
                V_Flag = 0;        }     //93,9,3
                step_mode=ONINPUT;
                sent_back_msg();
                if (wait_flag) cls_inpt_bf(1);
                    else cls_inpt_bf(1);         //1993. cock
                }

            else{
               if ((kb_mode==CIN_SDA)&&(input_char==0x27)){  //1993. cock
                step_mode=ONINPUT;      //1993. cock
                sent_back_msg();       //1993. cock
                if (wait_flag) cls_inpt_bf(1);
                    else cls_inpt_bf(1);         //1993. cock
                }//if(kb_mode)         //1993. cock
               else
                return(send_one_char(input_char));
               }
             }

    case ONINPUT:
         input_char_type=sent_chr1(input_char);

         switch(input_char_type){
            case REINPUT:
             ImeSetCompositionString(ghIMC,SCS_SETSTR,NULL,0,&InputBuffer,now_cs);//#52224

             step_mode=START;
             return(0);
             break;

            case CLC:
             return(0);       // Continue input.

            case STC:              // input finished
             if (V_Flag){
                msg_type=2;   //94/8/22
                send_msg(&in.buffer[1], in.true_length-1); //1993.3 skip the 'v'
                V_Flag = 0;
                step_mode = 0;
                return(0);}

             step_mode=4 ;    // enter proccessing step
             leibie=analize();
             if (leibie==BIAODIAN_ONLY){
                  out_result_area[0]=(BYTE)biaodian_value;
                  out_pointer=2;    // may not used
                  msg_type=0;
                  out_result(0);
                  step_mode=0;
                  return(0);
                  }             //only bioadian case

             return(call_czh(leibie));
        }// switch (sent_chr1)

    } //switch step_mode

    return 0;
}
/*******************************************************************
&2:
DealWithSH():
********************************************************************/
void WINAPI DealWithSH()
{
 int len,p;

if (group_no <= 1)
    return;
if (unit_length > 2)
    return;
if (in.true_length != 2) return;
 
if (in.buffer[0] !=     's') return;
if (in.buffer[1] != 'h') return ;

current_no = 1; 
}

/*******************************************************************
&2:
call_czh():
********************************************************************/
int WINAPI call_czh(mtype)
int mtype;
{
        int x;
        unsigned char prompt_flag_wu[]="�ޣ�";


        jiyi_mode=0;
        in.buffer[in.true_length]=0;
        sImeG.cp_ajust_flag = 0;
        group_no=0;
        unit_length=0;

        if (cwp_proc(mtype)!=1){
            MessageBeep((UINT)-1);
            MessageBeep(0);                       //word exchange is wrong
            MessageBeep(0);
            MessageBeep(0);                       //word exchange is wrong

            if (result_area_pointer>=0){
            //      jiyi_mode=0;
            //      group_no =0;
            //      cls_prompt_only();
            //      unit_length=result_area_pointer;
            //      out_result(1);
            //      step_mode=0;
            //      return(9);
            //      }//result_area
            //else{
            //      show_char(prompt_flag_wu,4);

                step_mode=ONINPUT;
                return(0);
                }
            } //cwp_proc=-1


            disp_jiyi(0);
            if (msg_type==2){
                current_no=0;
                move_result();
                out_result(1);   /* special change*/
                return(0);
                }
            if_jlxw_mode();
            fmt_transfer();
            current_no=0;
            DealWithSH();
            if (group_no==1){
                if (sImeG.cp_ajust_flag!=0)
                    result_area_pointer-=unit_length;
                move_result();
                step_mode=1;
                return(0);
                }//if (group_no=1)
            else{

                disp_tail=0;
                if (sImeG.cp_ajust_flag==1)
                    AutoMoveResult();
                else
                    move_result();

                SetToIMC(ghIMC,(BYTE *)&out_svw,(WORD)group_no,(WORD)unit_length);
                prompt_disp();
                step_mode=1;
                return(0);
                }//else
}

/**********************************************************************/
/* MoveWordIntoCand()                                                  */
/**********************************************************************/
void WINAPI MoveWordIntoCand(
    LPCANDIDATELIST lpCandList,
    LPBYTE            srcBuffer,
    BYTE             srcAttr,
    WORD             perLength )
{
  
    int i;

    if (lpCandList->dwCount >= MAXCAND) {
    return;
    }


                // add this string into candidate list
    for (i=0; i<perLength; i++)   
    *(LPBYTE)((LPBYTE)lpCandList + lpCandList->dwOffset[
        lpCandList->dwCount]+i) =srcBuffer[i] ;
    
                // null terminator

    *(LPTSTR)((LPBYTE)lpCandList + lpCandList->dwOffset[
    lpCandList->dwCount] + i ) = '\0';

    *(LPTSTR)((LPBYTE)lpCandList + lpCandList->dwOffset[
    lpCandList->dwCount] + i+1 ) = srcAttr;

    
    
    lpCandList->dwOffset[lpCandList->dwCount + 1] =
    lpCandList->dwOffset[lpCandList->dwCount] +
    i + sizeof(TCHAR)+1;
    lpCandList->dwCount++;

    return;
}

/**********************************************************************/
/* SetToIMC()                                                  */
/* Return vlaue                                                       */
/*      the number of candidates in the candidate list                */
/**********************************************************************/
UINT WINAPI SetToIMC(ghIMC,srcBuffer,srcCount,perLength)
    HIMC                ghIMC;
    BYTE               *srcBuffer; //soarce buffer (normal for out_svw) 
    WORD                srcCount;  //How many candidates are.            
    WORD                perLength; //How long of each of that? 
{
    LPINPUTCONTEXT      lpIMC;
    LPCANDIDATEINFO lpCandInfo;
    LPCANDIDATELIST lpCandList;
    LPPRIVCONTEXT   lpImcP;
    INT             i,j,nRecord,where;
    WORD                    temp[20],xx,yy;
    LPSTR           ppt;
    static      int CandiCount;

    where = 0 ;
    if (perLength>0x1000){
        perLength -=0x1000;  // if where = 1, msg_type = 2
        where = 1;} 
     

    if (!ghIMC) return (0); // The IMC must be a valid one.
   
    lpIMC = (LPINPUTCONTEXT)ImmLockIMC(ghIMC);
    if(!lpIMC)  return 0; 
  
    if (srcBuffer) ClearCand(lpIMC);

    if (!lpIMC->hCandInfo){
    ImmUnlockIMC(ghIMC);
     return (0); }
                        // The CandInfo must...

    lpCandInfo = (LPCANDIDATEINFO)ImmLockIMCC(lpIMC->hCandInfo);
    if (!lpCandInfo) {
    ImmUnlockIMC(ghIMC);
    return (0);}


    lpCandList = (LPCANDIDATELIST)
    ((LPBYTE)lpCandInfo + lpCandInfo->dwOffset[0]);
if(srcBuffer){
    CandiCount = srcCount;
    lpCandList->dwCount = 0;
    for (i=0; i<(int)srcCount; i++){
        if ( where ) {
             ppt = (LPSTR)temp;
         for (j=0; j<perLength; j++)
                ppt[j] = srcBuffer[i*perLength+j];
                      }
         else {
              for(j=0; j<perLength; j=j+2){
                xx = srcBuffer[i*perLength+j];
                yy = srcBuffer[i*perLength+j+1]*0x100;
                yy = yy + xx;
             temp[j/2]=(WORD)find_hz(yy);
                } // for j loop
              }  // else loop

        MoveWordIntoCand(lpCandList,
                 (LPSTR)temp,
                         0,//NULL,
                         perLength);
    } //for i loop
                                    // default start from 0
    lpCandList->dwSelection = 0;
                                    // for showing phrase prediction string(s)
    nRecord = lpCandInfo->dwCount;

} else {

           lpCandList->dwSelection = perLength;
           //Hack for IME aware application 9/13/96
           lpCandInfo->dwCount = CandiCount;    
           // for showing phrase prediction string(s)
           nRecord = lpCandInfo->dwCount;
         }


    lpImcP = (LPPRIVCONTEXT)ImmLockIMCC(lpIMC->hPrivate);
   
    if ( lpImcP != NULL )
    {
        if ((lpImcP->fdwImeMsg & (MSG_ALREADY_OPEN|MSG_CLOSE_CANDIDATE)) ==
            (MSG_ALREADY_OPEN|MSG_CLOSE_CANDIDATE)) {
                lpImcP->fdwImeMsg = (lpImcP->fdwImeMsg | MSG_CHANGE_CANDIDATE) &
                                    ~(MSG_CLOSE_CANDIDATE);
        } else if (lpImcP->fdwImeMsg & MSG_ALREADY_OPEN) {
            lpImcP->fdwImeMsg |= MSG_CHANGE_CANDIDATE;
        } else {
            lpImcP->fdwImeMsg = (lpImcP->fdwImeMsg | MSG_OPEN_CANDIDATE) &
                                ~(MSG_CLOSE_CANDIDATE);
        }
    }

    ImmUnlockIMCC(lpIMC->hPrivate);
    ImmUnlockIMCC(lpIMC->hCandInfo);
    ImmUnlockIMC(ghIMC);
    return (nRecord);    /* The real number of being moved */
}




/********************************************************************
  word_select(wParam): select the word or turn to the next or up page
*********************************************************************/
int WINAPI word_select(input_char)
int input_char;
{
    int x;

    switch (input_char){

       case VK_END*0x100:
       case VK_NEXT*0x100:
       case '=':                               //94/8/22
       case ']':
      if (disp_tail>=group_no)
          MessageBeep(0);
      else{

          if(input_char == VK_END*0x100 ){
              disp_head = (group_no - 1)/now.fmt_group*now.fmt_group;
              disp_tail = disp_head;}

          fmt_transfer();
          current_no=disp_tail;
        result_area_pointer-=unit_length;       //if recall, unit_length=8
        if (in.info_flag==1)                    //result_area_pointer maybe small
            result_area_pointer=0;                  //than zero, so reset it =0

          move_result();
          prompt_disp();}
      return(1);                            //means break the STD MODE

       case VK_HOME*0x100:
       case '-':                                //94/8/22
       case '[':
       case VK_PRIOR*0x100:
       if (disp_head==0)

           MessageBeep(0);
       else{
          
          if(input_char == VK_HOME*0x100 )
            disp_head = 0;
          else
           disp_head=disp_head-now.fmt_group;
           
           disp_tail=disp_head;
           fmt_transfer();
          current_no=disp_tail;
        result_area_pointer-=unit_length;       //if recall, unit_length=8
        if (in.info_flag==1)                    //result_area_pointer maybe small
            result_area_pointer=0;                  //than zero, so reset it =0
          move_result();
           prompt_disp();
           }
       return(1);

    default:
       if (if_biaodian((BYTE)input_char)){                //1993.1.15 cock
        if (!biaodian_value){
        sent_chr1(input_char);          //this produce the situation
        bd_proc();                      //when the result had display
        while(out_result(0));           //94-4-22
            step_mode=START;
        return(1);                      //1993.1.15 cock
        }
           }

        if ( !if_number_or_not((BYTE)input_char))  {      //1993.4.22
        while(out_result(0));       //94-4-22                    //if input is not number
        step_mode = START;                      //send the result and set start step
        return(1);
        }                                       //1993.4.22

        if(input_char=='0') x=disp_head+9;                  //92/12/21 SZ
        else
        x=(input_char-0x30-1)+disp_head;

        if (x>=group_no)                 //1994.4
            current_no=group_no-1;
        else
            current_no=x;
        result_area_pointer-=unit_length;       //if recall, unit_length=8
        if (in.info_flag==1)                    //result_area_pointer maybe small
            result_area_pointer=0;                  //than zero, so reset it =0
        else{
             if((step_mode==RESELECT)
                &&biaodian_value
                &&(result_area_pointer>=biaodian_len))
                result_area_pointer-=biaodian_len;
            }

        move_result();
        pindu_ajust();
        step_mode=RESELECT;                         //Note: pindu_ajust
        out_result(0);                              // must above out_result
        return(1);                                 // step_mode must be set to 2(Re..)
    }
}

/*********************************************
del_and_reconvert()
**********************************************/
int WINAPI del_and_reconvert()
{
    int x;

    if (word_back_flag==0xaa)
        return(same_as_backwords());

    wp.dw_count--;
    x=wp.dw_stack[wp.dw_count+1]-wp.dw_stack[wp.dw_count];
    if (x==1){                      //if the single word exchange
        if (!wp.dw_count)
            return(same_as_backwords());
        else{
            wp.dw_count--;
            x=wp.dw_stack[wp.dw_count+1]-wp.dw_stack[wp.dw_count]+1;
            }
        }
    result_area_pointer-=x*2;
    word_back_flag=x-1;
    wp.xsyjw=wp.dw_stack[wp.dw_count];
    return(call_czh(13));

}

/***********************************************
backword_proc()
************************************************/
int WINAPI backword_proc()
{
    switch(step_mode){
        case SELECT:
            return(same_as_backwords());
            break;

        case RESELECT:
        case START:
              if ((!msg_type)&&((kb_mode==CIN_STD)||(kb_mode==CIN_SDA)))
                return(same_as_backwords());
               else
                send_msg(msg_bf,msg_count);
               break;
        case ONINPUT:
            return(call_czh(14));
            break;
        }

    return 0;
}

/***********************************************
same_as_backwords()
************************************************/
int WINAPI same_as_backwords()
{
    int i;

    if (in.buffer[0]!='v'){
        cls_prompt_only();
        if (in.true_length>=1)
            if (in.buffer[0]!='U')
                if (!cap_mode){
                    cs_p(input_msg_disp);
                    show_char(in.buffer,in.true_length);
                    cs_p(input_msg_disp+in.true_length);
                    half_init();
                    if (kb_mode==CIN_STD||kb_mode==CIN_SDA){                                //STD_MODE
                        step_mode=ONINPUT;
                        return(0);
                        }//if (kb_mode)
                    return(read_kb());                              //double hit input_mode
                    }//if (cap_mode)

        }//if (in.buffer[0])
    out_length=last_out_length;
    return(REINPUT);

}
/*******************************************
 AutoMoveResult()
********************************************/
void WINAPI AutoMoveResult()
{
     int i,j,ct;
     WORD x;
     BYTE *ps,*pd;

     x=(WORD)unit_length;
     j=unit_length*current_no;

     for (i=0;i<group_no;i++){
        ct=0;
        for (j=0; j<x; j++)
           if (result_area[result_area_pointer+i]==out_svw[j*unit_length+i])
              ct++;
           if (ct == x){
              current_no=i;
              break;}
        }

    disp_auto_select();

}


/*******************************************
 move_result()
********************************************/
void WINAPI move_result()
{
     int i,j;
     WORD x;
     BYTE *p;

     p=(BYTE *)msx_area;
     if (in.info_flag==1){                                              // recall statue
        x=*(p+current_no*22);
        j=current_no*22+1;
        for (i=0; i<x; i++)
            result_area[result_area_pointer++]=*(p+j+i);
        }
     else{
        x=(WORD)unit_length;
        j=unit_length*current_no;
        for (i=0; i<x; i++)
        result_area[result_area_pointer++]=out_svw[j+i];
        }

     if (now.fmt_start!=12)
        disp_auto_select();

}

/********************************************
pindu_ajust()
********************************************/
int WINAPI pindu_ajust()
{
    if (sImeG.auto_mode!=1)
        return(0);                              //if the pindu_ajust mode is set
    if (group_no<=1)
        return(0);
    if (unit_length>6)
        return(0);
    if (msg_type&2)
        return(0);

    switch (unit_length){
        case 2:
            rem_pd1((WORD *)&out_svw[current_no*unit_length]);
            break;
        case 4:
            rem_pd2((WORD *)&out_svw[current_no*unit_length]);
            break;
        default:
            rem_pd3((WORD *)&out_svw[current_no*unit_length]);
            break;
        }
    return (0);
}




/***********************************************************
cls_inpt_bf():  inputing information init. clear the display
        area, and give the init_value to processing
        paraments.
************************************************************/
void WINAPI cls_inpt_bf(int hFunc)
{
    int i;
     cls_prompt_only();
     input_cur=0;//input_msg_disp;

     for (i=0;i<in.max_length;i++)
         in.buffer[i]=0;

     for (i=0;i<sizeof InputBuffer; i++) InputBuffer[i]=' ';
     SetCloseCompWinMsg(hFunc); 
     cs_p(0/*input_msg_disp*/);
     

     pass_word=0;
     group_no=0;
     now.fmt_group=0;
     disp_head=0;
     disp_tail=0;

     in.true_length=0;
     in.info_flag=0;

     result_area_pointer=0;

     word_back_flag=0;

     biaodian_value=0;

     msg_type=0;
     jiyi_mode=0;
     new_no=0;
     end_flg=0;

}


void InitCvtPara(void){
     int i;

     input_cur=0;//input_msg_disp;

     for (i=0;i<in.max_length;i++)
         in.buffer[i]=0;

     for (i=0;i<sizeof InputBuffer; i++) InputBuffer[i]=' ';
     now_cs = 0;
     cs_p(now_cs);
     
     step_mode = 0;
     pass_word=0;

     in.true_length=0;
     in.info_flag=0;

     result_area_pointer=0;

     word_back_flag=0;

     biaodian_value=0;

     msg_type=0;
     jiyi_mode=0;
     new_no=0;
     end_flg=0;

     V_Flag = 0;
     bx_inpt_on = 0;
}


/*****************************************
half_init()
******************************************/
void WINAPI half_init()
{
    step_mode=ONINPUT;
    result_area_pointer=0;
    biaodian_value=0;
    new_no=0;
    msg_type=0;
    word_back_flag=0;
    jiyi_mode=0;
    input_cur=now_cs;
}

/*******************************************************
sent_chr1(): send the string received from the keyboard
         to the received buffer.
         "JMP K1":     return(REINPUT)
         "JMP RECALL": return(RECALL)
         "STC":        return(STC)
         "CLC":        return(CLC)
********************************************************/
int WINAPI sent_chr1(input_char)
int  input_char;
{
    int bd_find=0,i;

    if ((input_char < 0x21)||(input_char == 0x12e)){
    switch(input_char){

       case VK_ESCAPE:               //VK_ESCAPE=0x1b:
        cls_inpt_bf(0);
        return(REINPUT);              /* JMP K1 */

       case VK_SPACE:                 //CK_SPACE=0x20
        in.info_flag=BY_WORD;
        return(STC);                  /* STC */

       case VK_DELETE+0X100:
        if (in.true_length>input_cur){
            for (i=0;i<in.true_length-input_cur-1;i++)
             in.buffer[input_cur+i]
                =in.buffer[input_cur+i+1];
            in.true_length--;

           in.buffer[in.true_length]=0x20;
            cs_p(0);
            show_char(in.buffer,in.true_length+1);
            cs_p(input_cur);
            return(CLC);}               /* CLC */
        else{
             MessageBeep(0);
             return(CLC);}


       case VK_BACK:                                //VK_BACK=0x08
        if (!input_cur){
            if (in.true_length){
            MessageBeep(0);
            return(CLC); }     //1993.4 oringal return(CLC)
            else {
            MessageBeep(0);
            return(REINPUT); }     //1993.4 oringal return(CLC)
            }

        in.true_length--;                  //1993.4.16
        if ( !in.true_length ) {           //1993.4.16
            end_flg=0;                     //????
            input_cur=0;
            cls_inpt_bf(0);
            V_Flag=0;                           //93.9.4
            return(REINPUT);}                  /* JMP K1 */
        else{
            input_cur--;
            for (i=0;i<in.true_length-input_cur;i++)
             in.buffer[input_cur+i]
                =in.buffer[input_cur+i+1];
           in.buffer[in.true_length]= 0; //0x20;         //95/8/22 zst
            cs_p(0);                                                     
            show_char(in.buffer,in.true_length/*+1*/);   //95/8/22 zst
            cs_p(input_cur);
            return(CLC);}               /* CLC */

       case VK_RETURN:                 //VK_RETURN=0x0d:
        in.info_flag=BY_CHAR;
        new_no=0;
        return(STC);                   /* STC */
       default:
        MessageBeep(0);
        return(CLC);                   /* CLC */
      }
       }

    else{
    switch(input_char){
       case VK_LEFT+0x100:
            if (input_cur>0) input_cur--;
            cs_p(input_cur);
            return (CLC);
       case VK_RIGHT+0x100:
            if (input_cur<in.true_length) input_cur++;
            cs_p(input_cur);
            return (CLC);
       case VK_UP+0x100:
               input_cur=0;
               cs_p(input_cur);
            return(CLC);
       case VK_DOWN+0x100:
               input_cur=in.true_length;
               cs_p(input_cur);
            return (CLC);

        case ']':
        case '[':
    if (!V_Flag)
        {
          if (input_char==']')
             jlxw_mode=1;
          else
             jlxw_mode=-1;
          in.info_flag=BY_WORD;
          return(STC);                    /* STC */
        }

        default:
        if (if_biaodian((BYTE)input_char) && (!V_Flag))     //1993,3
              bd_find=1;

        if (in.max_length<=in.true_length){
                              // in.true_length=in.max_length;
            MessageBeep(0);
            return(CLC);       //1994.4  old =STC               // changed 12-12 SZ
            }

        else{
            if(input_cur>=in.true_length){
            in.buffer[in.true_length++]=(BYTE)input_char;
            show_char(&in.buffer[input_cur],1); //1994.4.5
            input_cur++;
            cs_p(input_cur); // zst 95.54

            if (bd_find==1)
                return(STC);                               /* STC */
            else
                return(CLC);}
            else{

            if((!input_cur)&&((input_char&0xdf)=='V'))
                        return(CLC);   //1994.7.24

            for (i=0; i<in.true_length-input_cur;i++)
                in.buffer[in.true_length-i]
                =in.buffer[in.true_length-i-1];                                                        /* CLC */
            in.buffer[input_cur++]=(BYTE)input_char;
            if (!bd_find){
                    in.true_length++;
                    cs_p(0);
                    show_char(in.buffer,in.true_length);
                    cs_p(input_cur);
                    return(CLC);
                      }
             else{
                       for(i=input_cur;i<in.true_length;i++)
                       in.buffer[i]=0x20;  //1993.4.20
                    cs_p(0);
                    show_char(in.buffer,in.true_length);
                    cs_p(input_cur);
                       in.true_length=(WORD)input_cur;  //1993.4.20
                    return(STC);
                  }

             }//#4 if now_cs...else
              }//#3 if max...else
        }//#2 case
    }//#1 if..else
}//#0


/*******************************************************
&4:
if_biaodian(x): judge if the input is "biaodian"
        return(FALSE): NO
        return(TRUE):  YES
********************************************************/
BOOL if_biaodian(x)
BYTE x;
{
    int i;
    if ((step_mode==ONINPUT)&&(x==0x27)) return(FALSE); //94/8/22

    if (x=='$') {
          if((in.buffer[0]&0xdf)=='I')
                if((step_mode!=START)&&(step_mode!=RESELECT))
                    return (FALSE);}

    for (i=0; i<lstrlen(biaodian_table); i++){
        if (x==biaodian_table[i]){
            biaodian_pos=i;        /* record the porsition in biaodian_table */
            return(TRUE);
        }
    }
     return(FALSE);
}

/******************************************************
&3:
analize(): analize the input information
        process the biaodian , and analize the
        first byte of the input information.
        return(BIAODIAN_ONLY): chinese biaodian
        return(0):             standard change
        return(1):             ABBR
        return(2):             "I" change
        return(3):                              "i" change
        return(4):             "u" change
        return(0xff):           trun to "remember forced"
*******************************************************/
int WINAPI analize()
{
    if (bd_proc())
    return(BIAODIAN_ONLY);     /* only have the chinese biaodian */


    switch (in.buffer[0]){
    case 'I':
        return(2);             /* special change: "l" change */

    case 'i':

       return(3);              /* special change: "i" change */
    case 'u':
    case 'U':   //in.buffer[0]='U';
       if (in.true_length==1)
           return(0xff);       /* CTRL_F4_ENTRY: trun to the "remember forced" */
       else
           return(4);          /* special change: "u" change */
    }
    if ((in.buffer[0]&0x20)==0)                 /*1992 9 5 &&->& */
        return(1);                          /* ABBR */
    else
        return(0);                      /* mark of the standard change */


}

/***************************************************
&4:
 bd_proc(): process the chinese biaodian
        return(FALES):  have chinese biaodian and another char
        return(TRUE): only have the chinese biaodian
****************************************************/
BOOL bd_proc()
{          
   BYTE x;

   x=in.buffer[in.true_length-1];

   if(!GetBDValue(x)) return(FALSE);

   in.true_length--;
   if (in.true_length==0)
    return(TRUE);
   else
    return(FALSE);
}

int WINAPI GetBDValue(bd_char)
int bd_char;
{
   if (!if_biaodian((BYTE)bd_char))
    return(FALSE);

   biaodian_len =2;
   if ((bd_char=='^')||(bd_char=='^'))
       biaodian_len =4;

   biaodian_value=cc_biaodian[biaodian_pos*2]+
            cc_biaodian[biaodian_pos*2+1]*0x100;
   if (bd_char==0x22){
      if (yinhao_flag==1)
    biaodian_value=cc_biaodian[(biaodian_pos+2)*2]
            +cc_biaodian[(biaodian_pos+2)*2+1]*0x100;
      yinhao_flag=!yinhao_flag;                  //92-12-21 SZ
      }
   if (bd_char==0x27){
      if (d_yinhao_flag==1)
    biaodian_value=cc_biaodian[(biaodian_pos+2)*2]
            +cc_biaodian[(biaodian_pos+2)*2+1]*0x100;
      d_yinhao_flag=!d_yinhao_flag;                  //92-12-21 SZ
      }

  if(bd_char=='<'){
      if(book_name==1){
               biaodian_value=cc_biaodian[(biaodian_pos+10)*2]
            +cc_biaodian[(biaodian_pos+10)*2+1]*0x100;
              book_name_sub++;
               }
      else{
     book_name=1;
     book_name_sub=0;
        }
     }

  if(bd_char=='>'){
      if(book_name_sub){
               biaodian_value=cc_biaodian[(biaodian_pos+10)*2]
            +cc_biaodian[(biaodian_pos+10)*2+1]*0x100;
              book_name_sub--;
               }
     else
    book_name=0;
        }

     return(TRUE);
}

/*******************************************************
&4:
 if_zimu_or_not(): judge if the input is char or number
           return(TRUE):  is char
           return(FALSE): is number
********************************************************/
BOOL if_zimu_or_not(x)
BYTE x;
{
    if (('A'<=x) && (x<='Z'))
    return(TRUE);
    if (('a'<=x) && (x<='z'))
        return(TRUE);

    return(FALSE);
}


/***************************************************
if_number_or_not(c)
****************************************************/
int WINAPI if_number_or_not(c)
BYTE c;
{
if ((c<'0')||(c>'9'))
   return(STC);
else
  return(CLC);

 }

/***************************************************
if_bx_number(c)
****************************************************/
int WINAPI if_bx_number(c)
BYTE c;
{
if ((c<'1')||(c>'8'))    
   return(STC);
else
  return(CLC);

 }


/*********************************************************
&3:
 out_result(result_type): output the change result.
**********************************************************/

int WINAPI out_result(result_type)
int result_type;
{
    int i;

    if ((jiyi_mode==1)){
        if (word_back_flag==0x99){
            word_back_flag=2;
            return(call_czh(13));}
        else{

              if  (call_czh(12)==9){
                step_mode=START;
                }
              else
            step_mode=SELECT;
            return(1);
            }
        } // if (jiyi)

    else{
        if (result_area_pointer!=unit_length)
            if (msg_type!=2)
                if (in.info_flag!=1)
                    new_no=result_area_pointer;

    if (biaodian_value!=0){
        result_area[result_area_pointer++]=LOBYTE(biaodian_value);
        result_area[result_area_pointer++]=HIBYTE(biaodian_value);
    
       if (biaodian_len==4)
        {
            result_area[result_area_pointer++]=LOBYTE(biaodian_value);
            result_area[result_area_pointer++]=HIBYTE(biaodian_value);
            }

        }

    if (!(msg_type&2)){
        if (result_area_pointer>0){
            temp_rem_proc();
            for (i=0; i<result_area_pointer; i=i+2)
                out_bfb[i/2]=(WORD)find_hz((WORD)(result_area[i]+result_area[i+1]*0x100));
            } // if (result_area_pointer)
        last_out_length=out_length;
        out_length=result_area_pointer/2;
        AddExtLib();
        send_msg((BYTE *)out_bfb,result_area_pointer);
        } // if (msg_type)
    else{
        last_out_length=out_length;
        out_length=result_area_pointer/2;
        send_msg(result_area,result_area_pointer);
        if (in.buffer[0]!='v'){
            step_mode=0;
            return(0);}
        }

    return(0);

    }
}
//////////////////////////////////////////////////////////////////////////

void WINAPI fmt_transfer()
{

   if (lpImeL->wImeStyle == IME_APRS_FIX){
    if (in.info_flag==BY_RECALL)
          { now.fmt_group=3;  //5;
           now.fmt_start=26;
           now.fmt_ttl_len=54;
           word_back_flag=0x55;        //back convert is not allowed.
          }
     else
          { now.fmt_group=(WORD)form[unit_length/2];
           now.fmt_start=27;
           now.fmt_ttl_len=53;
          }

    } else {

      now.fmt_group = CANDPERPAGE ;
      if (in.info_flag==BY_RECALL)
              word_back_flag=0x55;
        }

}
//////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////

int WINAPI sent_back_msg()
{
    if (new_no<=2)
        return(0);
    if (new_no>18)
        return(0);
    new_word();
    return(0);

}

//////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////
int WINAPI if_jlxw_mode()
{
      int x,i,j;
      WORD *out_svw_p;

    out_svw_p=(WORD *)out_svw;

    if (jlxw_mode==0)
        return(0);
    if (jlxw_mode<0){
        if (sImeG.cp_ajust_flag==1)
            result_area_pointer=result_area_pointer-unit_length+2;
        x=0;
        } // if (jlxw)
    else{
        if (sImeG.cp_ajust_flag==1){
            x=result_area_pointer-unit_length;
            result_area[x++]=result_area[result_area_pointer-2];
            result_area[x++]=result_area[result_area_pointer-1];
            result_area_pointer=x;
            }// if (cp_ajust)
        x=unit_length-2;
        }// else

    jlxw_mode=0;
    word_back_flag=0xaa;
    if (unit_length<=2)
        return(0);

    j=0;
    x=x/2;                          //out_svw_p transmit by word;
    for (i=0; i<group_no; i++){
        out_svw_p[j++]=out_svw_p[x];
        x+=unit_length/2;
        }// for
    unit_length=2;

    for (i=0; i<group_no; i++)
        out_svw_p[i+100]=out_svw_p[i];

    x=0;
    for (i=0; i<group_no; i++){
        if (out_svw_p[i+100]){
            out_svw_p[x]=out_svw_p[i+100];
            for (j=i+1; j<group_no; j++){
               if (out_svw_p[j+100]==out_svw_p[x])
                out_svw_p[j+100]=0;
               }//for(j)
            x++;
            }//if(out_svw_p)
        }//for(i)

    group_no=x;
    return(0);

}
//////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////

int WINAPI disp_auto_select()

{
    WORD x,y,lng;
    int i,j;
    BYTE disp_bf[80];

    if (result_area_pointer==0)
        return(0);
    cs_p(input_msg_disp);
    if (msg_type==2){
        show_char(result_area, result_area_pointer);
    cs_p(input_msg_disp+result_area_pointer);
        }
    else{
         for (i=0; i<result_area_pointer; i=i+2){
          x=result_area[i]+result_area[i+1]*0x100;
          y=(WORD)find_hz(x);
              disp_bf[i]=LOBYTE(y);
              disp_bf[i+1]=HIBYTE(y);
              }// for
         lng=in.true_length;
         if (jiyi_mode!=0){
        if (wp.xsyjw!=0){
            if (wp.yj_ps[wp.xsyjw-1]<in.true_length){
                    j=wp.yj_ps[wp.xsyjw-1];
                    x=in.true_length-wp.yj_ps[wp.xsyjw-1];
                    for (n=0; n<x; n++){
                        disp_bf[i++]=in.buffer[j++];
                        }//for
                    }// if (yj_ps)
                }//if(wp.xsyjw)
            }// if (jiyi)

        show_char(disp_bf, i);

         cs_p(input_msg_disp+result_area_pointer);
         }// else


    return (0);
}


//////////////////////////////////////////////////////////////////////////


int WINAPI if_first_key(input_char)
WORD input_char;
{

    if (input_char=='U') return(STC);

    if(if_number_or_not((BYTE)input_char))
             return(STC);                               //the first key is number,it's not allowed

    if(if_zimu_or_not((BYTE)input_char))
             return(CLC);                               //the first key is zimu


    return(STC);
}


/*****************************************************************
temp_rem_proc(): save the output in logging_stack for recall process
********************************************************************/
int WINAPI temp_rem_proc()
{
    int c,i;

    if (in.true_length<2)
        if (in.info_flag!=1)
            return(0);

    if (biaodian_value){
        c=result_area_pointer-2+1;              //-2 biaodian isn't consider
        if ((c>=2)&&(biaodian_len==4))
              c = c-2;
        }
    else                                                            //+1 logging_stack struck is
        c=result_area_pointer+1;                //   result_area_pointer plus
                                        //    one byte counter

    CopyMemory/*memmove*/(&logging_stack[c],&logging_stack[0],(logging_stack_size-c));

    logging_stack[0]=c-1;                           //length of storing string
    for (i=0; i<logging_stack[0]; i++)
        logging_stack[i+1]=result_area[i];

    if_multi_rem(c);
    return(0);

}

/*******************************************
if_multi_rem()
********************************************/
int WINAPI if_multi_rem(c)
int c;
{
    BYTE cmp_buffer[25]={0};     //max input is 10 chinese words
    int i,cn;
    char *p;

    for (i=0; i<c; i++)
        cmp_buffer[i]=logging_stack[i];
    cmp_buffer[i]=0;

    p=(LPSTR)ABCstrstr(&logging_stack[c],cmp_buffer);
    if (p!=NULL){
        c=(INT)(p-logging_stack);
        cn=logging_stack[c]+1;   //cn is the length a group in logging_stack
        CopyMemory/*memmove*/(&logging_stack[c],&logging_stack[c+cn],logging_stack_size-c-cn);
        }
    return(0);

}


/////////////////////////////////////////////////////////////////////
void WINAPI send_msg(bf,count)
BYTE *bf;
int count;
{
    int i,j;
    unsigned int focus,xx;

    TypeOfOutMsg = ABC_OUT_MULTY ;
    msg_count=count;             //Keep msg for repeat.
    for (i=0;i<count;i++){
         msg_bf[i]=bf[i];            //send msg for Edit class W.
         if (bf[i]<0x80)  TypeOfOutMsg = ABC_OUT_ASCII;
         }
   SetResultToIMC(ghIMC,msg_bf,(WORD)count);
   

}

 /*******************************************
 Popurse: To send a single char as message .
 *******************************************/
int WINAPI send_one_char(chr)
 int  chr;
 {
 int scn;
    if(glpIMC->fdwConversion&IME_CMODE_SYMBOL)
         if(GetBDValue(chr)){
             unsigned char buffer[4];
             int num = 2; 

         buffer[0]=LOBYTE(biaodian_value);
             buffer[1]=HIBYTE(biaodian_value);
    
       if ((chr == '_')||   (chr == '^'))
       {
            buffer[2]=LOBYTE(biaodian_value);
            buffer[3]=HIBYTE(biaodian_value);
            num = 4 ;
       }
       send_msg(buffer,num);
       return(0);
    }

    if(glpIMC->fdwConversion&IME_CMODE_FULLSHAPE)
         cap_full((WORD)chr);
    else
        TypeOfOutMsg = ABC_OUT_ONE ;
    return(0);

 }

int WINAPI send_one_char0(chr)
int chr;
{
        TypeOfOutMsg = ABC_OUT_ONE ;
        return (0);
}



/**********************************************************************/
/* SetResultToIMC()                                                  */
/* Return vlaue                                                       */
/*      the number of candidates in the candidate list                */
/**********************************************************************/
 UINT WINAPI SetResultToIMC(
    HIMC                ghIMC,
    LPSTR               outBuffer, //soarce buffer (normal for out_svw) 
    WORD                outCount)  //How many candidates are.            
{
    LPINPUTCONTEXT      lpIMC;
    LPCANDIDATEINFO lpCandInfo;
    LPCANDIDATELIST lpCandList;
    LPPRIVCONTEXT   lpImcP;
    LPCOMPOSITIONSTRING lpCompStr;
    WORD                        dwCompStrLen;
    WORD                        dwReadClauseLen;
    WORD                        dwReadStrLen;

    if (!ghIMC) return (0); // The IMC must be a valid one.
   
    lpIMC = (LPINPUTCONTEXT)ImmLockIMC(ghIMC);
    if(!lpIMC)  return 0; 
  
    if (!lpIMC->hCandInfo){
    ImmUnlockIMC(ghIMC);
     return (0); }
                        // The CandInfo must...

    lpCandInfo = (LPCANDIDATEINFO)ImmLockIMCC(lpIMC->hCandInfo);
    if (!lpCandInfo) {
    ImmUnlockIMC(ghIMC);
    return (0);}


    lpCandList = (LPCANDIDATELIST)
    ((LPBYTE)lpCandInfo + lpCandInfo->dwOffset[0]);

    lpCompStr = (LPCOMPOSITIONSTRING)ImmLockIMCC(lpIMC->hCompStr);


    if (!lpCompStr) {
    MessageBeep((UINT)-1);
    ImmUnlockIMCC(lpIMC->hCandInfo);
    ImmUnlockIMC(ghIMC);
    return (0);
    }


    dwCompStrLen = 0;
    dwReadClauseLen = 0;
    dwReadStrLen = 0;

    InitCompStr(lpCompStr);

    // the result reading clause = compsotion reading clause
    CopyMemory((LPSTR)lpCompStr + lpCompStr->dwResultReadClauseOffset,
    (LPSTR)lpCompStr + lpCompStr->dwCompReadClauseOffset,
    dwReadClauseLen);
    lpCompStr->dwResultReadClauseLen = dwReadClauseLen;
    *(LPSTR)((LPSTR)lpCompStr+lpCompStr->dwResultReadClauseOffset+dwReadClauseLen) = '\0';

    // the result reading string = compsotion reading string
    CopyMemory((LPSTR)lpCompStr + lpCompStr->dwResultReadStrOffset,
    (LPSTR)lpCompStr + lpCompStr->dwCompReadStrOffset,
    dwReadStrLen);
    lpCompStr->dwResultReadStrLen = dwReadStrLen;
    *(LPSTR)((LPSTR)lpCompStr+lpCompStr->dwResultReadStrOffset+dwReadStrLen) = '\0';
   
    // calculate result string length
    lpCompStr->dwResultStrLen = outCount;

    // the result string = outBuffer;
    CopyMemory((LPSTR)lpCompStr + lpCompStr->dwResultStrOffset,
        (LPSTR)outBuffer,outCount);
    *(LPSTR)((LPSTR)lpCompStr+lpCompStr->dwResultStrOffset+outCount) = '\0';

    lpCompStr->dwResultClauseLen = 0;
    *(LPUNADWORD)((LPBYTE)lpCompStr + lpCompStr->dwResultClauseOffset +
    sizeof(DWORD)) = 0;


    lpImcP = (LPPRIVCONTEXT)ImmLockIMCC(lpIMC->hPrivate);

    // tell application, there is a reslut string
    lpImcP->fdwImeMsg |= MSG_COMPOSITION;
    lpImcP->dwCompChar =  (DWORD)0;
    lpImcP->fdwGcsFlag |= GCS_COMPREAD|GCS_COMP|GCS_CURSORPOS|
    GCS_DELTASTART|GCS_RESULTREAD|GCS_RESULT;

    if(TypeOfOutMsg == ABC_OUT_ASCII)
        lpImcP->fdwGcsFlag &=(~GCS_RESULT);


    if (lpImcP->fdwImeMsg & MSG_ALREADY_OPEN) {
    lpImcP->fdwImeMsg = (lpImcP->fdwImeMsg | MSG_CLOSE_CANDIDATE) &
        ~(MSG_OPEN_CANDIDATE);
    }

    // no candidate now, the right candidate string already be finalized
    lpCandList->dwCount = 0;

    lpImcP->iImeState = CST_INIT;


    ImmUnlockIMCC(lpIMC->hPrivate);
    ImmUnlockIMCC(lpIMC->hCandInfo);
    ImmUnlockIMC(ghIMC);
    return (0) ;    /* The real number of being moved */
}



/**********************************************************
    FUNCTION: cap_full()
    PURPOES:  if the full_switch on, and in the Caps status,
              change the English into Chinese mode
************************************************************/
void WINAPI cap_full(wParam)
WORD wParam;
{

         if (wParam==VK_BACK){
                  //        send_one_char(VK_BACK);
                 send_one_char0(VK_BACK);
                 return;
                     }

         if (wParam==VK_SPACE){
                result_area[0]=0xa1; //94-8-6!
                result_area[1]=0xa1; //04-8-6!
                send_msg(result_area,2);
                return;
                }

     if (wParam== '~'){
                result_area[0]=0xa1; //94-8-6!
                result_area[1]=0xab; //04-8-6!
                send_msg(result_area,2);
                return;
                }


         if (wParam=='$'){
                result_area[0]=0xa1; //94-8-6!
                result_area[1]=0xe7; //04-8-6!
                send_msg(result_area,2);
                return;
                }


        if ((wParam>0x20) && (wParam<=0x7e)){
            result_area[0]=0xa3;
            result_area[1]=((wParam-0x20)*0x100+0xa0a3)/0x100;

            send_msg(result_area,2);
            return;
            }

            send_one_char0(wParam);
}

/*********************************************
read_kb()
**********************************************/
int WINAPI read_kb()
{
  return(0);
}


/////////////////////////////////////////////////////////////////////////
//                              BX_MODE                                                                                            //
//              Deel with pure bx input                                                                            //
/////////////////////////////////////////////////////////////////////////

extern WORD last_size;

BX_MODE(input_char,wParam)
WORD input_char;
WPARAM wParam;
{

    if (if_number_or_not((BYTE)input_char)
            &&(input_char!='9')
            &&(input_char!='0')){
        if (step_mode==START||step_mode==RESELECT){
            if (input_char >= 0x8000)       //1993.4.19
                return(STC);           //when RESELECT use the mouse reselect result
            else {
                if (!bx_inpt_on)
                  { cls_bx_disp(1);
                    sent_back_msg();
                  }
                step_mode=ONINPUT;
                bx_inpt_on=1; }//else
        } //if (step_mode)
      }//if (if_number...)

    if (bx_inpt_on){
        bx_proc(input_char,wParam);
        return(CLC);
            }

    return(STC);

}

/**********************************************************************
    FUNTION:        bx_proc(WORD)
    PURPOSE:        when the pure bx were inputed, find one chinese word
                corespond with it and eight related words with it.
***********************************************************************/
void WINAPI bx_proc(input_char,wParam)
WORD input_char;
WPARAM wParam;
{
    int i;

    lib_p=(BYTE *)lib_w;                    //lib_p point to the lib_buffer

    switch (bx_analize(input_char,wParam))
    {
 
    case BX_CHOICE:
        if (input_char>=0x8000){
            current_no=(input_char - 0x8000-0x31)+disp_head;
        sImeG.InbxProc = 0;
    }else
        current_no=((INT)wParam - 0x31)+disp_head;           
        if(current_no>=group_no){     
            MessageBeep(0);
            disp_help_and_result();
        }else
            send_bx_result();
        break;

        case BX_SELECT:
        word_select_bx(input_char);
        break;

        case ESC:
        cls_bx_disp(0);
        break;

        case OTHER:
        MessageBeep(0);
        disp_help_and_result();
        break;

       
        case SPACE:
        send_bx_result();
        break;

        case BXMA:
        if(!disp_help_and_result()){
            if(in.true_length>1){
                 in.true_length--;
                     MessageBeep(0);
                     disp_help_and_result();
                     }
           }
        break;

        default:
        break;
    }//swith
}




/********************************************************************
  word_select(wParam): select the word or turn to the next or up page
*********************************************************************/
 word_select_bx(input_char)
int input_char;
{
    int x;
     

    switch (input_char){

       case VK_END*0x100:
       case VK_DOWN*0x100:
       case '=':                               //94/8/22
       case ']':
      if (disp_tail>=group_no)
          MessageBeep(0);
      else{

          if(input_char == VK_END*0x100 ){
              disp_head = (group_no - 1)/now.fmt_group*now.fmt_group;
              disp_tail = disp_head;}

          fmt_transfer();
          current_no=disp_tail;
          prompt_disp();}
      return(1);                            //means break the STD MODE

       case VK_HOME*0x100:
       case '-':                                //94/8/22
       case '[':
       case VK_UP*0x100:
       if (disp_head==0)

           MessageBeep(0);
       else{
          
          if(input_char == VK_HOME*0x100 )
            disp_head = 0;
          else
           disp_head=disp_head-now.fmt_group;
           
           disp_tail=disp_head;
           fmt_transfer();
          current_no=disp_tail;
           prompt_disp();
           }
       return(1);

    default:
        return(1);                      //1993.1.15 cock
        }
}


/************************************************************************
    FUNTION:        bx_analize(WORD)
    PURPOSE:        analize the input char. find out if it is pure bx
*************************************************************************/
int WINAPI bx_analize(input_char,wParam)
WORD input_char;
WPARAM wParam;
{
    if(input_char>=0x8000) return(BX_CHOICE);

    if (input_char == VK_UP*0x100)
          return(BX_SELECT);

    if (input_char == VK_DOWN*0x100)
          return(BX_SELECT);

    if (input_char == VK_HOME*0x100)
          return(BX_SELECT);

    if (input_char == VK_END*0x100)
          return(BX_SELECT);

    if (input_char == ']')
          return(BX_SELECT);

    if (input_char == '[')
          return(BX_SELECT);

    if (input_char == '-')
          return(SELECT);

    if (input_char == '=')
          return(SELECT);


    if (input_char==VK_ESCAPE)
        return(ESC);

    if (input_char==VK_SPACE)
    {
        in.info_flag=0x80;                      //standard end flag
        return(SPACE);
    }

    if (input_char==VK_RETURN)
    {
        in.info_flag=0x80;                      //standard end flag
        return(SPACE);
    }

    if (input_char==VK_BACK)
    {
        if (in.true_length==1)
        {
        input_char=VK_ESCAPE;   //if it has inputed only one word
        return(ESC);
        }                   //cls the display
        in.true_length--;
        key_bx_code_long=in.true_length;
        return(BXMA);
    }

    if (!if_bx_number((BYTE)input_char))
    {
       if( ((BYTE)wParam>'0') && ((BYTE)wParam <= CANDPERPAGE+0x30))
         return (BX_CHOICE);   
    
        in.info_flag=(BYTE)input_char;    //rest key is put into the end_flag position
        return(OTHER);
    }

    if ((input_char>0x30)||(input_char<0x39))
    {
        if (in.true_length>6)
        {
        in.info_flag=(BYTE)input_char;
        return(OTHER);
        }
        else
        {
        in.buffer[in.true_length++]=(BYTE)input_char;
        key_bx_code_long=in.true_length;
        return(BXMA);
        }
    }
    else{
        in.info_flag=(BYTE)input_char;
        return(OTHER);
    }

}

/************************************************************************
    FUCTION:        disp_help_and_result()
    PURPOSE:        seach the bx_table and display the tishi result
    ENTRY:          bx string is in inpt_bx.bf
    RESULT:         display the result and tishi information
**************************************************************************/
int WINAPI disp_help_and_result()
{
    int i, pass_flag;

    if (in.true_length==1)
       if (in.buffer[0]!=in_mem_part)               //if this part of table is in memory
          load_one_part_bxtab();

    for (i=0; i<in.true_length; i++)
          key_bx_code[i]=in.buffer[i]&0x0f;         // 'and' high 4 bit

    search_pointer=0;
    current_bx_code_long=0;
    pass_flag=0;
    while (search_pointer<current_part_length)
    {
        if (cmp_bx_word_exactly())
        {                                           //search correct result
        pass_flag=1;
        break;
        }
    }
    if (!pass_flag)
                return 0;


    for (i=0; i<8*2; i++)
        out_svw[i]=0;           //clear the prompt result buffer

    search_pointer=0;
    current_bx_code_long=0;
    pass_flag=0;
    while (search_pointer<current_part_length)
        if (cmp_bx_code2())                 //search the related prompt result
        pass_flag=1;                    //if found it, set the flag and continue

    if (pass_flag)
    {
        disp_bx_result();
        disp_bx_prompt();
    }
    else
    {
        if (group_no>1){                            //1993.3
            disp_bx_result();               //1993.3
            disp_bx_prompt();
            }
        else                                    //1993.3
            send_bx_result();
    }
   return 1;
}

/***********************************************************************
    FUCTION:        cmp_bx_word_exactly()
    PURPOSE:        find the correct result position, and send the result
                into buffer.
    ENTRY:          the input bx is in the key_bx_code buffer
    RESULT:         CLC--- the input bx is matched with the current bx in the table
                       the correct result is in the out_svw buffer
                STC--- not match
                the search_pointer points the position the next bx in
                the table.
************************************************************************/
int WINAPI cmp_bx_word_exactly()
{
    BYTE x;
    int i;

    for (i=0;i<20;i++)
        result_area[i]= 0;
    conbine();              //get the bx from the bx_table

    result_area_pointer=0;
    if (key_bx_code_long==current_bx_code_long){
        if (cmp_subr()){
            group_no=0;
            search_pointer++;
            while (lib_p[search_pointer]>0xa0){
            //      result_area[result_area_pointer++]=group_no|0x40;
            //      result_area[result_area_pointer++]=0x2e;
                result_area[result_area_pointer++]=lib_p[search_pointer++];     //save the "quma"
                result_area[result_area_pointer++]=lib_p[search_pointer++];     //save the "weima"
            //      result_area[result_area_pointer++]=0x20;
                group_no++;                                             //sum of chinese word
                }//while
            return(CLC);
            }//if (cmp_subr())
        }//if(key_bx_code_long)

    search_pointer++;
    while (lib_p[search_pointer]>=0xa0)
        search_pointer+=2;                              //move the pointer to the beginning
    return(STC);                                            //of the next bx in the table

}

/**************************************************************************
    FUCTION:        cmp_bx_code2()
    PURPOSE:        search the prompt information and get the chinese word
                which is related with the input.
**************************************************************************/
int WINAPI cmp_bx_code2()
{
    WORD x;

    conbine();                      //get the bx from the bx_table

    if (key_bx_code_long==(current_bx_code_long-1)){
        if (cmp_subr()){
            bx_help_flag|=0x80;

            x=(lib_p[search_pointer++]&0x0f)-1;
            if (x>7)                //if the bx overflow
                x=7;

            out_svw[x*2]=lib_p[search_pointer++];   //get the prompt bx
            out_svw[x*2+1]=lib_p[search_pointer++];

            while (lib_p[search_pointer]>0xa0)
                search_pointer+=2;      //move the pointer to the next string

            return(CLC);
            }//if (cmp_subr())
        }//if (key_bx_code_long)

    search_pointer++;
    while (lib_p[search_pointer]>0xa0)
        search_pointer+=2;                      //move the pointer to the next string
    return(STC);

}

/************************************************************************
    FUCTION:        conbine()
    PURPOSE:        get the bx from the table and change the high 4 bit into
                the position where the last bit of bx should put in and
                get this string of bx's length.
*************************************************************************/
void WINAPI conbine()
{
    int x;

    x=(lib_p[search_pointer]>>4)&0x0f;
    current_bx_code[x]=lib_p[search_pointer]&0x0f;
    current_bx_code_long=x+1;

}


/***********************************************************************
    FUCTION:        cmp_surb()
    PURPOSE:        compare the input bx with the bx in the table
************************************************************************/
int WINAPI cmp_subr()
{
    int i;

    for (i=0; i<key_bx_code_long; i++)
        if(key_bx_code[i]!=current_bx_code[i])
            return(STC);

    return(CLC);

}

void WINAPI cls_bx_disp(int flag)
{
  if(!flag)
    cls_prompt();
 
    input_cur=input_msg_disp;
    cs_p(input_msg_disp);
    in.true_length=0;
    in.info_flag=0;
    bx_inpt_on=0;
    group_no=0;
    current_no = 0;
    step_mode=START;
}


int WINAPI load_one_part_bxtab()
{
    int hd, close_hd;
    int op_count,i;
    WORD distance;


    in_mem_part=in.buffer[0]&0x0f;          //save the current first bx ma
    distance=bxtable_ndx[in_mem_part-1];    //get the beginning position
    current_part_length=bxtable_ndx[in_mem_part]-distance; //get the read length
    hd=OpenFile("winabc.ovl",&reopen,OF_READ);
    if (hd==-1)
    {
       err_exit_proc("OPEN WINABC.OVL ERROR!");
       return (FALSE);
    }

    _llseek(hd,distance,0);
    last_size=0;
    last_item_name=0;
    op_count=_lread(hd,&lib_w,current_part_length);
    
    lib_p[op_count]=0;
    lib_p[op_count+1]=0;    // cls the below limited

    if (op_count!=current_part_length)
    {
       err_exit_proc("READ WINABC.OVL ERROR!");
       close_hd = _lclose(hd);
       return (FALSE);
    }

    
    close_hd = _lclose(hd);

    return (TRUE);
}

int WINAPI disp_bx_result()
{
    BYTE buffer[50];
    int keep_cs, i;

    for (i=0; i<50; i++) buffer[i] = ' ' ;
     
    input_cur=input_msg_disp;
    cs_p(input_msg_disp);
    for (i=0; i<in.true_length; i++)
         buffer[i]= in.buffer[i];

    show_char(buffer, i);
    now_cs= i;                      //restore
    cs_p(now_cs);                   //disp cs
    return (0);
}

void WINAPI disp_bx_prompt()
{
    int i,j,n;
    HWND hhh;
    int GroupCounter;
    BYTE buffer [100];


    disp_head=0;
    disp_tail=8;

    j=0,n=0;
    GroupCounter= 0;
    if (group_no) {             //if the results are more the 5
    for (i=0; i<group_no*2; i=i+2)      //display the rest in the prompt area
       if(result_area[i]){
        buffer[j++]=result_area[i];
        buffer[j++]=result_area[i+1];
        buffer[j++]=0xa1;
        buffer[j++]=0xa1;} 
    }

    n =group_no*2;
    for(i=0; i<16; i = i+2){
        if(out_svw[i]){
         buffer[j++] = out_svw[i];
         result_area[n++] = out_svw[i];
         buffer[j++] =   out_svw[i+1];
         result_area[n++] = out_svw[i+1];
         buffer[j++] = 0xa2;
         buffer[j++] = 0xd9+GroupCounter;}
        GroupCounter++;
        }//for
    

    group_no = j/4;

    unit_length = 4;
       current_no=0;
           disp_tail=0;
           V_Flag=0;
           msg_type=2;                       //94/8/22
           fmt_transfer();
           SetToIMC(ghIMC,(LPSTR)&buffer,(WORD)group_no,(WORD)(unit_length+0x1000));                            
           prompt_disp();
           step_mode=SELECT;
}

void WINAPI send_bx_result()
{
    out_length=1;
    send_msg(&result_area[current_no*2],2);
    cls_bx_disp(1);

}





////////////////////////////////////////////////////////////////////////
//          ��ʼ�������� data_init()                                  //
//   ����: ���������ļ�                                               //
//         ���� 1. ?MMR.REM                                           //
//              2. ������������, ������Ƶ�ȱ�,�����ʻ���              //
//              3. ������׼�ʿ����û��ʿ��IJ���.                      //
//              4. ����TMMR.REM, �����û��ʿⲻ����,����֮.           //
//              5. �����û��ʿ�                                       //
//  ���ڲ���: ��                                                      //
//  ���ڲ���: TURE  ��ʼ���ɹ�                                        //
//            FALSE ��ʼ��ʧ��                                        //
////////////////////////////////////////////////////////////////////////


void WINAPI data_init()
{

BYTE    new_flag=0;                     //һ�δ����û��ļ�?
BYTE    the_para='U';                   //�����IJ���
BYTE    disp_mode=0;
BYTE    current_dd=0;
BYTE    current_disk='C';
BYTE    current_path[64];
HFILE   hd;
DWORD   op_count;
BYTE    tmp_buffer[16]={0};
int     i;

char    god[]="WINABC.CWD";
char    cw_ovr[]="WINABC.OVL";
char    no_file[]=ERR01;                    //ȱ�ٴʿ��ļ�WINABC.CWD
char    read_ndx_wrong[]=ERR03;             //"�ļ���������";
char    m_short[]=ERR14;                    //"�ڴ治����";
char    no_cw_ovr[]=ERR04;                  //"ȱ�ٻ������ļ�WINABC.OVL��";
char    jiyi_wenjian_cuo[]=ERR13;           //"�û������ļ�������!";
char    TMMR_WRITE_WRONG[]=ERR09;           // "�����ļ�д��";

OFSTRUCT ofs;

LPSTR cisu_1;

    memset(tmmr_rem, 0, sizeof(tmmr_rem));
    memset(user_lib, 0, sizeof(user_lib));

// support  multi-user

    lstrcpy(tmmr_rem,  sImeG.szIMEUserPath);
    lstrcat(tmmr_rem,  TEXT("\\tmmr.rem") );

    lstrcpy(user_lib,  sImeG.szIMEUserPath);
    lstrcat(user_lib,  TEXT("\\user.rem") );

    hd =OpenFile(god, &ofs, OF_READ|OF_SHARE_COMPAT|GENERIC_READ);
    if ( hd==HFILE_ERROR)
        err_exit(no_file);
    op_count = _lread(hd,&ndx,NDX_REAL_LENGTH);
        
    if(op_count!=NDX_REAL_LENGTH)
        err_exit(read_ndx_wrong);

    _lclose(hd);

    hd = OpenFile(cw_ovr, &ofs, OF_READ|OF_SHARE_COMPAT|GENERIC_READ);
    if (hd==HFILE_ERROR)
        err_exit(no_cw_ovr);
    
    _llseek(hd, PTZ_LIB_START_POINTER, FILE_BEGIN); // ����ָ��

    cisu_hd=GlobalAlloc(GMEM_MOVEABLE,(DWORD)PTZ_LIB_LENGTH);
    if (!cisu_hd)
    {
        err_exit(ERR22);       //Memory Alloc Wrong!");
        _lclose(hd);
        return;
    }
 
    cisu_1=GlobalLock(cisu_hd); /*GlobalWire* for v32*/
                                                 
    if (!cisu_1)
        err_exit(ERR22);     //"Memory Alloc Wrong!");

    cisu=(struct TBF FAR *)cisu_1;
    op_count=_lread((HFILE)hd,(LPSTR)&cisu->t_bf_start,PTZ_LIB_LENGTH);    // ������������

    if (op_count!=PTZ_LIB_LENGTH)
        err_exit(ERR06);  //"Read WINABC.OVL Wrong!");

    _llseek((HFILE)hd, PD_START_POINTER, 0);        //����ָ��
    op_count=_lread((HFILE)hd,(LPSTR)&pindu.pd_bf0,PD_LENGTH);            //������ӡ����Ƶ�ȱ�
    if (op_count!=PD_LENGTH)
        err_exit(ERR06);  //("Read WINABC.OVL Wrong!");

    _llseek(hd, SPBX_START_POINTER, 0);        //����ָ��
    op_count=_lread(hd,(LPSTR)&spbx_tab,SPBX_LENGTH);        // �����������α�
    if (op_count!=SPBX_LENGTH)
        err_exit(ERR06);   //("Read WINABC.OVL Wrong!");
    _lclose((HFILE)hd);


    if (CheckAndCreate(tmmr_rem,user_lib)){
        hd = OpenFile(tmmr_rem, &ofs, OF_READWRITE);           //1993.4.15
        if (hd==HFILE_ERROR)
            err_exit(ERR13);   //(jiyi_wenjian_cuo);
        op_count=_lread(hd,(LPSTR)&tmmr,TMMR_REAL_LENGTH);
        if (op_count!=TMMR_REAL_LENGTH)
            err_exit(ERR06);  //(jiyi_wenjian_cuo);

        _llseek(hd,TMMR_REAL_LENGTH,0); //move the pointer to the paremeter area
        op_count=_lread(hd,tmp_buffer, PAREMETER_LENGTH); //read the paremeters to the buffer
        if (!op_count) {                                    //1993.4.15 if old tmmr.rem hasn't this ten parameters
            memset(tmp_buffer, 0 , PAREMETER_LENGTH);

            tmp_buffer[0] = (BYTE)IfTopMost;                  //transfer the peremeters
            tmp_buffer[1] = sImeG.auto_mode ;
            tmp_buffer[2] = bdd_flag;
            tmp_buffer[3] = sImeG.cbx_flag;

            op_count = _lwrite((HFILE)hd, rem_area, PAREMETER_LENGTH);   //writer the file
            if (op_count!=PAREMETER_LENGTH)
                err_exit (ERR09);   //(TMMR_WRITE_WRONG);
        }//if (!op_count)
        else {
            if (op_count!=PAREMETER_LENGTH)
                err_exit(ERR08);      //(jiyi_wenjian_cuo);
        }//else

        _lclose(hd);

        IfTopMost = tmp_buffer[0];                      //transfer the paremeter
        sImeG.auto_mode = tmp_buffer[1];                 //1993.4
        bdd_flag = tmp_buffer[2];
        sImeG.cbx_flag = tmp_buffer[3];

        hd = OpenFile(user_lib, &ofs, OF_READ);           //1993.4.15
        if (hd==-1)
            err_exit(ERR10);     //(jiyi_wenjian_cuo);
        _llseek(hd,0xa000l,0);
        op_count=_lread(hd,(LPSTR)&kzk_ndx,NDX_REAL_LENGTH);
        if (op_count!=NDX_REAL_LENGTH)
            err_exit(ERR11);    //(jiyi_wenjian_cuo);
        _lclose(hd);
    }

}




//
//Popose: check user_word dictionary files "TMMR.REM"
//                                         "USER.REM"
//         If they are not exist, created.
//

int WINAPI CheckAndCreate(tmmr_rem,user_rem)
BYTE *tmmr_rem,*user_rem;
{
struct INDEX user_file_head;
struct M_NDX mulu_head={
            0,
            0,       //MULU_START_LOW                Ŀ¼��д���ֽ�
            0x1800,  //MULU_LENGTH_MAX   SIZELIB+SIZELIB_KZK   Ŀ¼���󳤶�=�����صij���
            0x10,    //MULU_TRUE_LENGTH  10H      Ŀ¼��ʵ�ʳ���,��ʼֻ�в���.
            0xA,     //MULU_RECORD_LENGTH  10  Ŀ¼ÿ����¼�ij��ȡ�
            0,       //DATA_START_HI  0  �����û��ļ�������64K֮��.
            0x1800,   //DATA_START_LOW DW SIZE LIB_W      Ŀ¼�����������������ν�.
            0x20};   //DATA_RECORD_LENGTH 32 ÿ����¼�ij���.

OFSTRUCT ofs;
int hd,i,count;
HANDLE hMem;
LPSTR rem_area,p;
WORD *pp;

char TMMR_OPEN_WRONG[]= ERR07;    //"�����ļ��򿪴�";
char TMMR_READ_WRONG[]= ERR08;    //"�����ļ�����";
char TMMR_WRITE_WRONG[]=ERR09;    // "�����ļ�д��";
char USER_OPEN_WRONG[]= ERR10;    //"�û��ʿ��򿪴�";
char USER_READ_WRONG[]= ERR11;    //"�û��ʿ�����";
char USER_WRITE_WRONG[]=ERR12;    // "�û��ʿ�д��";


hMem=GlobalAlloc(GMEM_FIXED|GMEM_ZEROINIT ,TMMR_LIB_LENGTH );

if ( hMem == NULL )
   return 0;

rem_area=GlobalLock(hMem);

hd = OpenFile(tmmr_rem, &ofs, OF_READ);
if (hd!=-1){
    count = _lread(hd, rem_area, TMMR_LIB_LENGTH);
    if ((rem_area[CHECK_POINT]=='T')&& (rem_area[CHECK_POINT+1]=='X')
                    && (rem_area[CHECK_POINT+2]=='L')
                    && (rem_area[CHECK_POINT+3]=='N'))
                    _lclose(hd);
    else
        _lclose(hd),hd=-1;
       } // if (hd!=-1)....

if (hd==-1){
     hd = OpenFile(tmmr_rem, &ofs, OF_CREATE|OF_SHARE_DENY_NONE);
          if (hd==-1)
             err_exit(TMMR_OPEN_WRONG);
          else{
            for (i = 0; i<TMMR_LIB_LENGTH; i++)
                rem_area[i]=0;                  // Init the temp rem
                                // area by zero.
            rem_area[CHECK_POINT]='T';
            rem_area[CHECK_POINT+1]='X';
            rem_area[CHECK_POINT+2]='L';
            rem_area[CHECK_POINT+3]='N';
                                //give Mark!

             count = _lwrite(hd, rem_area, TMMR_LIB_LENGTH);
            if (count!=TMMR_LIB_LENGTH)
                 err_exit(TMMR_WRITE_WRONG);

            for (i=0; i<PAREMETER_LENGTH; i++)
                rem_area[0]=0;          //clear the buffer

            rem_area[0] = (CHAR)IfTopMost;        //transfer the peremeters
            rem_area[1] = sImeG.auto_mode =0;
            rem_area[2] = bdd_flag=0;
            rem_area[3] = sImeG.cbx_flag=0;

            count = _lwrite(hd, rem_area, PAREMETER_LENGTH);   //writer the file
            if (count!=PAREMETER_LENGTH)
                err_exit (TMMR_WRITE_WRONG);

            _lclose(hd);               //close the file
          } //else...
         }//if (hd==-1)...


//
// Check or create TMMR.REM file is over. Now, deel with USER.REM.
//
hd = OpenFile(user_rem, &ofs, OF_READ);
if (hd!=-1){
    _llseek(hd,(LONG)LENGTH_OF_USER, 0);
    count = _lread(hd, rem_area, NDX_REAL_LENGTH);

    if ((rem_area[CHECK_POINT2]=='T')&&(rem_area[CHECK_POINT2+1]=='X')
                     &&(rem_area[CHECK_POINT2+2]=='L')
                     && (rem_area[CHECK_POINT2+3]=='N'))
                    _lclose(hd);
    else
        _lclose(hd),hd=-1;
       } // if (hd!=-1)....

if (hd==-1){
     hd = OpenFile(user_rem, &ofs, OF_CREATE|OF_SHARE_DENY_NONE);
          if (hd==-1)
             err_exit(USER_OPEN_WRONG);
          else{
            for (i = 0; i<TMMR_LIB_LENGTH ; i++)
                rem_area[i]=0;                  // Init the temp rem
                                // area by zero.
 // First, write file para for force remenber.

           p=(BYTE *)&mulu_head.mulu_start_hi;
           for (i=0; i<16; i++) rem_area[i]=p[i];

// Init force rem file

          for (i=0; i<LENGTH_OF_USER/0x1000; i++){
            count = _lwrite(hd, rem_area, 0x1000);
            if (count!=0x1000 )
                 err_exit(USER_WRITE_WRONG);}

//Init user dictionary file
          p=(BYTE *)&user_file_head.body_start;
          for (i=0; i<sizeof user_file_head;i++)  p[i]=0;

          user_file_head.body_start=NDX_REAL_LENGTH/16;
          user_file_head.ttl_length=NDX_REAL_LENGTH/16;
          user_file_head.body_length=0;
          user_file_head.index_start=3;
          user_file_head.index_length=NDX_REAL_LENGTH/16-3;
          user_file_head.unused1=0x2000;


          p[CHECK_POINT2]='T';
          p[CHECK_POINT2+1]='X';
          p[CHECK_POINT2+2]='L';
          p[CHECK_POINT2+3]='N';
                                //give Mark!

             count = _lwrite(hd,(LPSTR)&user_file_head, NDX_REAL_LENGTH  );
            if (count!=NDX_REAL_LENGTH  )
                 err_exit(TMMR_WRITE_WRONG);
           _lclose(hd);
          } //else...
         }//if (hd==-1)...

    GlobalUnlock(hMem);
    GlobalFree(hMem);
    return(CLC);
}// create and check



//
// ������������,ĿǰΪģ��������, ��������Ϊһ���Ի���
// ���ص���Ϣ����: RETRY, IGNORE, CANCEL
//

void WINAPI err_exit(err_msg)
char *err_msg;
{

   MessageBox(hWnd, err_msg, "ERR", MB_OKCANCEL);
   PostMessage(hWnd,WM_DESTROY,0,0l);
}


void WINAPI err_exit_proc( err_msg)
char *err_msg;
{

   MessageBox(NULL, err_msg, "ERR", MB_OKCANCEL);
   return ;
}


 int WINAPI GetText32(   HDC  hdc,LPCTSTR  lpString,int  cbString)
 {
     
    
    SIZE  lSize;  
   
    GetTextExtentPoint32(hdc,lpString,cbString,(LPSIZE)&lSize);

    return lSize.cx;
 }


 int WINAPI makep(LPARAM lParam,  LPPOINT oldPoint)
 {
   
   POINTS newPoint;
     newPoint=MAKEPOINTS(lParam);
     oldPoint->x=(WORD)newPoint.x;
     oldPoint->y=(WORD)newPoint.y;
     return 0;
}         



/*******************************************************
&3:
 cwp_proc():
********************************************************/
int WINAPI cwp_proc(mtype)
int mtype;
{
    int i, j, m;
    BYTE x;
    switch (mtype){
        case 0:
            return(normal());                   //normal pinyin convert

        case 1:
            abbr();                            //ABBR
            return(normal());

        case 2:                                 // "I" capital chinese number
        case 3:                                 // "i" small chinese number
            if (in.true_length==1){
                in.buffer[1]='1';
                in.true_length++;}
            if (in.true_length>20) in.true_length=20;

            m=0;
            for(i=1; i<in.true_length; i++){
                x=in.buffer[i];
                if (if_number_or_not(in.buffer[i])){
                if (mtype==2)
                   x=in.buffer[i]-0x30;
                }
                if (if_zimu_or_not(in.buffer[i])){
                x=in.buffer[i]&0xdf;
                   if (mtype==2)
                      if (x=='S' || x=='B' || x=='Q')
                    x=x|0x20;
                }

                for (j=0; j<160; j=j+3){
                if (x==fk_tab[j]){
                     out_svw[m++]=fk_tab[j+1];
                     out_svw[m++]=fk_tab[j+2];
                     x=0xff;              // found it
                     break;}
                }// for(j)
             if (x!=0xff)
               goto err_back;

             } // for(i)

             group_no=1;
             unit_length=m;
             msg_type=2;
             return(1);                 // success!

        case 4:                                 // "u" user define word
            return(user_definition());

        case 12:                                //continue to change
            return(find_next());

        case 13:                                // backword
            return(normal_1(word_back_flag));

        case 14:
            return(recall());

        default:
          err_back:
            return(-1);

    }// switch
}



/************************************************
find_next()
*************************************************/
int WINAPI find_next()
{
    if (wp.yjs<=wp.xsyjw)
        return(STC);

    return( normal_1(0) );
    
}


/*************************************************
normal()
**************************************************/
int WINAPI normal()
{
    extb_ps=0xffff;
    by_cchar_flag=0;
    wp.yjs=0;
    wp.xsyjw=0;
    wp.dw_count=0;
    wp.dw_stack[0]=0;

    if (in.info_flag==0x81)
        by_cchar_flag=1;
    detail_analyse();
    
    if (!convert(0)){
        zdyb();
        return(STC);
        }
        
    wp.xsyjs=wp.xsyjw;
    wp.xsyjw+=word_long;
    wp.dw_stack[++wp.dw_count]=(BYTE)wp.xsyjw;

    if (by_cchar_flag!=1){
        if (wp.yjs==wp.xsyjw){
            if (wp.xsyjs!=0){
                sfx_attr=2;                     //mark for finding sfx_table
                rzw();}
                }//if (wp.xsyjs)
        
        else{
            if (word_long<=1){
                if (wp.xsyjs==0){                                                                               
                    sfx_attr=1;                     //mark for finding sfx_table
                    rzw();}//if (wp.xsyjs)
                }//if (word_long)
            }//else

        }//if (by_cchar...
        
    if (wp.yjs<=wp.xsyjw)
        jiyi_mode=0;
    else
        jiyi_mode=1;

    return(CLC);
                
}

/*******************************************************
normal_1()
********************************************************/
int WINAPI normal_1(flag)
int flag;
{
    if (in.info_flag==0x81)
        by_cchar_flag=1;

    if (!convert(flag)){
        zdyb();
        return(STC);
        }

    wp.xsyjs=wp.xsyjw;
    wp.xsyjw+=word_long;
    wp.dw_stack[++wp.dw_count]=(BYTE)wp.xsyjw;

    if (by_cchar_flag!=1){
        if (wp.yjs==wp.xsyjw){
            if (wp.xsyjs!=0){
                sfx_attr=2;                     //mark for finding sfx_table
                rzw();}
                }//if (wp.xsyjs)
        
        else{
            if (word_long<=1){
                if (wp.xsyjs==0){                                                                               
                    sfx_attr=1;                     //mark for finding sfx_table
                    rzw();}//if (wp.xsyjs)
                }//if (word_long)
            }//else
                                
        }//if (by_cchar...

        
    if (wp.yjs<=wp.xsyjw)
        jiyi_mode=0;
    else
        jiyi_mode=1;

    return(CLC);

}

//////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////

int WINAPI recall()
{
    cls_prompt_only();
    in.info_flag=1;
    wp.yjs=0;
    wp.xsyjw=0;
    by_cchar_flag=0;
    detail_analyse();
    if (!recall_rc())
        return(-1);

    return (0);
    
}

/*************************************************************
user_definition(): produce the user define word
**************************************************************/
int WINAPI user_definition()
{
    int i,rec_cnt;

    kbf.max_length=in.max_length;
    kbf.true_length=in.true_length-1;               //delete the word "u"

    for (i=0; i<kbf.true_length; i++)
        kbf.buffer[i]=in.buffer[i+1];

    read_mulu();
    if (!(rec_cnt=look_for_code()))
        return(STC);                                            //not found
    if (!read_data(rec_cnt-1))                      //-1 get the real record count
        return(STC);                                            //not found

    unit_length=out_svw[0]-0x30;                            //plus 1 is plus the mark
    word_long=(out_svw[0]-0x30)/2;
    group_no=1;
    CopyMemory/*memmove*/(out_svw,&out_svw[2],unit_length);
    msg_type|=2;
    return(CLC);

}



/***************************************************************
detail_analyse()
***************************************************************/

int WINAPI detail_analyse()
{
    int i=0,j=0;
    BYTE *p;

    copy_input();

    p=(BYTE *)kbf.buffer;
    do{
        if (!slbl(p)){
            if (i==0)
                return(STC);
            else
                break;
            }

        if (sb.length==0)
            break;

        p+=sb.length;
        if (LOBYTE(sb.value)=='V')
            if (sb.head=='J'||sb.head=='Q'||sb.head=='X')
                (BYTE)sb.value='U';
        
        wp.syj[i]=sb.head;
        wp.bx_stack[i]=sb.bx1;
        wp.tone[i]=sb.tune;
        wp.yj[j]=sb.value;                          //WORD transport
        wp.yj_ps[j]=(int)(p-(BYTE *)kbf.buffer);
       
        i++, j++;
        if (i>=10)                      //10 1994.4
            break;

        if (sb.flag==TRUE)
            break;

      }while(1);

    wp.yjs=i;

    input_msg_type();

    return (0);
}




int WINAPI slbl(s_buffer)
BYTE *s_buffer;
{

    int i=0,j;
    BYTE cmp_buffer[5]={0};
    char *p;
    BYTE x,attr,y;

/*    analize the SHENGMU   */
    x=s_buffer[i++];
    attr=(BYTE)getattr(x,&x);                        // get char's attribute
    if (!attr){
        sb.length=i-1;
        sb.flag=TRUE;
        return(1);}

    if (attr==NUMBER)
        return(0);                   // error
    if (x=='I' || x=='U' || x=='V')
        return(0);                   // error
    switch (attr) {                    //1993.4.22
        case FIRST_T:
        case SECOND_T:
        case THIRD_T:
        case FORTH_T:
             return (0);            //error
        }                           //1993.4.22

    sb.value=0;
    sb.head=0;
    sb.length=0;
    sb.tune=0;
    sb.bx1=0;
    sb.bx2=0;
    sb.flag=FALSE;

    sb.head=x;
    if (attr==FUYIN){
         if (x=='Z' || x=='C' || x=='S' ){
        if ((s_buffer[i]&0xdf)==0x48){
               for (j=0; j<15; j=j+5){
                if (x==slbl_tab[j]){
                    sb.value=(WORD)slbl_tab[j+4]<<8;
                        sb.head=slbl_tab[j+4];
                        break;}
                     }// for()
               i++;
               }// if (s_buffer)
             else
            sb.value=(WORD)x<<8;
             }// if (x=='z')
         else
             sb.value=(WORD)x<<8;
         }//if (attr==FUYIN)
    else{
         i--;
         sb.value=0;
        } //else


/*    analize the YUNMU   */
    x=s_buffer[i];
    attr=(BYTE)getattr(x,&x);
    if (!attr){
         sb.length=(WORD)i;
         sb.flag=TRUE;
         return(1);}

    if (attr==YUANYIN){             //if no YUANYIN, goto step3
        (BYTE)sb.value=x;
        cmp_buffer[0]=x;
        i++;
        for (j=1; j<4; j++){
        x=s_buffer[i++];
        attr=(BYTE)getattr(x,&x);
        if (!attr){
            for (j=j; j<4; j++)
            cmp_buffer[j]='0';
            i--;
            sb.flag=TRUE;
            break;}

        if (attr==NUMBER){
            for (j=j; j<4; j++)
                cmp_buffer[j]='0';
            i--;
            break;
            }// if
        else
            cmp_buffer[j]=x;
        }//for

        for (j=3; j>0; j--){
           p=(LPSTR)ABCstrstr((LPSTR)slbl_tab,cmp_buffer);           //search the YUNMU
           if (p!=NULL){
           (BYTE)sb.value=*(p+4);               //get the YUNMU value
               break;
               }// if (p)
           if (cmp_buffer[j]!=0x30){
           cmp_buffer[j]='0';
               i--;}//if (cmp)
           }// for(j)


       }//if (x!=YUANYIN)
    else
         (BYTE)sb.value=0;


/*   see if the next is YUANYIN    */
    x=s_buffer[i];
    attr=(BYTE)getattr(x,&x);
    if (!attr){
       sb.length=(WORD)i;
       sb.flag=TRUE;
       if (sb.value<=0xff)
           sb.value=sb.value<<8;
       return(1);}
    if (attr==YUANYIN){
        y=s_buffer[i-1]&0xdf;
        if (y=='R'||y=='N'||y=='G'){
            i--;
            (BYTE)sb.value=0;
            for (j=3; j>0; j--){
                if (cmp_buffer[j]!=0x30){
                    cmp_buffer[j]='0';
                    break;}//if
                    }//for
        for (j=3; j>0; j--){
            p=(LPSTR)ABCstrstr((LPSTR)slbl_tab,cmp_buffer);           //search the YUNMU
            if (p!=NULL){
               (BYTE)sb.value=*(p+4);               //get the YUNMU value
                   break;
                   }// if (p)
            if (cmp_buffer[j]!=0x30){
               cmp_buffer[j]='0';
               i--;}//if (cmp)
            }// for(j)
            if (!(BYTE)sb.value)
               (BYTE)sb.value=cmp_buffer[0];
            }//if (y=='R')
        }//if (attr==YUANYIN)

    if (sb.value<=0xff)
        sb.value=sb.value<<8;

/*   analize the tune   */
    x=s_buffer[i];
    attr=(BYTE)getattr(x,&x);
    if (!attr){
       sb.length=(WORD)i;
       sb.flag=TRUE;
       return(1);}
    if (attr==FIRST_T||attr==SECOND_T||attr==THIRD_T||attr==FORTH_T){
        sb.tune=attr;
        i++;}



/*   analize the BIXING   */
    for (j=0; j<6; j++){
      x=s_buffer[i++];
      attr=(BYTE)getattr(x,&x);
      if (!attr){
        sb.flag=TRUE;
        sb.length=i-1;
        return(1);}

      if (attr==SEPERATOR){
          sb.flag=FALSE;
          sb.length=(WORD)i;
          return(1);                // if the string has seperator, move the
         }                  // pointer to the beginning of next YINJIE

      if (attr!=NUMBER){
        do{                     //1993.4.22
            if (attr==YUANYIN || attr==FUYIN){
                sb.flag=FALSE;
                sb.length=i-1;
                return(1);}

            x=s_buffer[i++];
            attr=(BYTE)getattr(x,&x);

            if (!attr){
                sb.flag=TRUE;
                sb.length=i-1;
                return(1);}
        }while(i<100);
        return (1);
      }                          //1993.4.22


      if (x>'0' && x<'9'){
          switch(j){
         case 0:
            sb.bx1=x<<4;
            break;
         case 1:
            sb.bx1+=x&0x0f;
            break;
         case 2:
            sb.bx2=(WORD)x;
            sb.bx2<<=12;
            break;
         case 3:
            sb.bx2=sb.bx2+(WORD)((x&0xf)<<8);
            break;
         case 4:
            (BYTE)sb.bx2=x<<4;
            break;
         case 5:
            (BYTE)sb.bx2+=x&0x0f;
            break;
         }//switch

      }//if(x)

    }// for

    do{
        x=s_buffer[i++];
        attr=(BYTE)getattr(x,&x);

    if (!attr){
        sb.flag=TRUE;
        sb.length=i-1;
        return(1);}

    if (attr==YUANYIN || attr==FUYIN){
        sb.flag=FALSE;
        sb.length=(WORD)i;
        return(1);}

    }while(i<100);

    return (0);

}



/*******************************************************
getchr(x)
*******************************************************/
int WINAPI getattr(x,p)
BYTE x;
char *p;
{
    if (x==0)
       return(FALSE);

    if (if_number_or_not(x))
       return(NUMBER);

    if (if_zimu_or_not(x)){
       x=x&0xdf;
       *p=x;
       if (x=='A'||x=='E'||x=='I'||x=='O'||x=='U'||x=='V')
        return(YUANYIN);
       else
        return(FUYIN);
       }

    if (x==SEPERATOR)
       return(SEPERATOR);


    switch(x){
        case '-':
        return(FIRST_T);
        case '/':
        return(SECOND_T);
        case '~':
        case '^':
        return(THIRD_T);
        case '\\':
          return(FORTH_T);

       }

    return (FALSE);
}



/*******************************************************
neg_slbl()
********************************************************/
int WINAPI neg_slbl(value)
WORD value;
{
    int i=0;
    BYTE x;

    s_tune();
    x=HIBYTE(value);
    if (x>=0x41)
        neg.buffer[i++]=x;
    else{
            if (x!=0)
                i=neg_sc(i,x);
        }

    x=LOBYTE(value);
    if (x>=0x41)
        neg.buffer[i++]=x;
    else{
        if (x!=0)
            i=neg_sc(i,x);
        }

    neg.buffer[i]=sb.tune;
    neg.length=i;
    for (x=0; x<i+1; x++)
        neg.buffer[x]=neg.buffer[x]|0x20;
    return(1);

}


/******************************************
neg_sc(i,x)
*******************************************/
int WINAPI neg_sc(i,x)
int i;
BYTE x;
{
    int j,n;

    n=(x-1)*5;
    for (j=0; j<4; j++){
        if (slbl_tab[n+j]!=0x30)
              neg.buffer[i++]=slbl_tab[n+j];
        else
            break;
        }
    return(i);
}



//      if (in.buffer[2]==1)
//              return(recall_rc());
//========================================================================
//     Covert
//========================================================================
//

int WINAPI convert(flag)
int flag;
{
    int j;

//      if (sb.bx2!=0)
//              return(0);

    if (!flag)
        word_long=wp.yjs-wp.xsyjw;
    else
        word_long=flag;

    if (word_long>9)                                                   //?
        word_long=9;                                            //?

    if (by_cchar_flag==1)
        word_long=1;

    if (word_long==1)
        return(pre_nt_w1(wp.xsyjw));



    for (j=word_long; j>1; j--){
        word_long=j;
        prepare_search1();
         abbr_s1();
        if (group_no){
            unit_length=j*2;
            return(CLC);
            }// if ()
        }// for()

    return(pre_nt_w1(wp.xsyjw));

}

/*********************************************
copy_input()
**********************************************/
int WINAPI copy_input()
{
    int i=0, j=0;

    if (in.info_flag==VK_MULTIPLY)                  //if "*"
        return(0);

    kbf.true_length=in.true_length;
    if (in.buffer[0]==SEPERATOR){
            kbf.true_length=in.true_length-1;
            i=1;
            }// if ((in.buffer)

    for (i=i; i<in.true_length+2; i++)
            kbf.buffer[j++]=in.buffer[i];

    kbf.max_length=in.max_length;
    kbf.info_flag=in.info_flag;

    return (0);

}

/**************************************************
input_msg_type()
**************************************************/
void WINAPI input_msg_type()
{
    int i;
    for (i=0; i<wp.yjs; i++){
        wp.cmp_stack[i]=QP_FLAG;
        if (LOBYTE(wp.yj[i])==0)
            if (wp.syj[i]==HIBYTE(wp.yj[i]))
                wp.cmp_stack[i]=JP_FLAG;

        if (wp.tone[i]!=0)
            wp.cmp_stack[i]|=YD_FLAG;

        if (wp.bx_stack[i]!=0)
            wp.cmp_stack[i]|=BX_FLAG;

        }// for


}

/*****************************************************
pre_nt_w1()
******************************************************/
int WINAPI pre_nt_w1(ps)
int ps;
{
    unit_length=2;
    word_long=1;
    cmp_yj=wp.yj[ps];
    cmp_head=wp.syj[ps];
    cmp_bx=wp.bx_stack[ps];
    cmp_state=wp.cmp_stack[ps];

    find_one_hi();

    w1_no_tune();
    return(group_no);

}

/********************************************************
w1_no_tune()
*********************************************************/
void WINAPI w1_no_tune()
{
    out_svw_cnt=0;
    sc_gb();
    sc_gbdy();
    group_no=out_svw_cnt;
    paidui(group_no);

}

/*********************************************************
sc_gb()
**********************************************************/
int WINAPI sc_gb()
{
    BYTE x;
    int cnt,i;

    cnt=(87-15)*94;
    if (cmp_state&4){
        if (cmp_bx==0){
            x=HIBYTE(cmp_yj);
            if (x!='A'&&x!='O'&&x!='E'){
                cnt=(55-15)*94;
                cmp_state=cmp_state|0x80;
                }// if (x=='A')
            else
                cmp_state=(cmp_state&0xfb)|QP_FLAG;

            }// if (!cmp_bx)
        }// if (cmp_state)

    for (i=0; i<cnt; i++){
        if (cmp_yj==cisu->t_bf1[i])
            get_the_one(i);
        else{
            if (cmp_state&4){
                if (cmp_head==HIBYTE(cisu->t_bf1[i]))
                    get_the_one(i);
                else
                     if ( cmp_head==fu_sm(HIBYTE(cisu->t_bf1[i])) )
                    get_the_one(i);

                }// if (cmp_state)
            }//else
        }//for()

    return(0);

}

/*******************************************************
sc_gbdy()
*******************************************************/
int WINAPI sc_gbdy()
{
    int cnt,i;

    cnt=cisu->t_bf_start[2]/2;
    for (i=0; i<cnt; i=i+2){
        if (cmp_yj==cisu->t_bf2[i])
            get_the_one2(i);
        else{
            if (cmp_state&4){
                if (cmp_head==HIBYTE(cisu->t_bf2[i]))
                    get_the_one2(i);
                else {
                 if (cmp_head==fu_sm(HIBYTE(cisu->t_bf2[i])))
                    get_the_one2(i);}
                }// if (cmp_state)
            }//else
        }//for()

    return(0);

}

/********************************************************
get_the_one()
*********************************************************/
int WINAPI get_the_one(i)
int i;
{
    BYTE x;

    WORD *out_svw_p=(WORD *)out_svw;
    BYTE *msx_p=(BYTE *)msx_area;

    if (cmp_bx1(i)!=0)
        return(0);

    out_svw_p[out_svw_cnt]=i+0x2020;

    if (i>=(55-16+1)*94)
        x=0x20;
    else
        x=pindu.pd_bf1[i];

    if (cmp_state&0x80){
        if (x<=(154+50)){
            return(0);
            }// if (x)
        }// if (cmp_state)
    msx_p[out_svw_cnt]=x;
    out_svw_cnt++;
    return(0);

}

/***********************************************************
cmp_bx1()
************************************************************/
int WINAPI cmp_bx1(i)
int i;
{
    BYTE x;

    if (cmp_bx==0)
        return(0);

    x=spbx_tab[i];
    if (x==cmp_bx)
        return(0);

    x=x&0xf0;
    if (x==cmp_bx)
        return(0);

    return(1);

}


/********************************************************
get_the_one2()
*********************************************************/
int WINAPI get_the_one2(i)
int i;
{
    BYTE x;

    WORD *out_svw_p=(WORD *)out_svw;
    BYTE *msx_p=(BYTE *)msx_area;

    if (cmp_bx2(i)!=0)
        return(0);

    out_svw_p[out_svw_cnt]=i+0x8000;

    if ((i/2)>=pindu.pd_bf0[2])
        x=0x20;
    else
        x=pindu.pd_bf2[i/2];

    if (cmp_state&0x80){
        if (x<=(154+50)){
            return(0);
            }// if (x)
        }// if (cmp_state)
    msx_p[out_svw_cnt]=x;
    out_svw_cnt++;
    return(0);

}

/***********************************************************
cmp_bx2()
************************************************************/
int WINAPI cmp_bx2(i)
int i;
{
    BYTE x;
    WORD y;

    if (cmp_bx==0)
        return(0);

    i++;
    y=cisu->t_bf2[i];
    y=((BYTE)y-0xb0)*94+(HIBYTE(y)-0xa1);

    x=spbx_tab[y];
    if (x==cmp_bx)
        return(0);

    x=x&0xf0;
    if (x==cmp_bx)
        return(0);

    return(1);

}

/***********************************************************
paidui()
************************************************************/
int WINAPI paidui(cnt)
int cnt;
{
    int i,j,n,flag;
    BYTE x1,y1;
    WORD x,y;
    WORD *out_p;
    BYTE *msx_p=(BYTE *)msx_area;

    out_p=(WORD *)out_svw;
    if (cnt<=1)
        return(0);

    for (n=cnt-1; n>0; n--){
        flag=0;
        for (i=0; i<n; i++){
        if (msx_p[i]==msx_p[i+1]){
            if (out_p[i]>out_p[i+1]){
                x=out_p[i];
                out_p[i]=out_p[i+1];
                out_p[i+1]=x;
                flag++;
                }//if (out_p)
            }// if (msx_p)
        else{
            if (msx_p[i]<msx_p[i+1]){
                x1=msx_p[i];
                msx_p[i]=msx_p[i+1];
                msx_p[i+1]=x1;
                x=out_p[i];
                out_p[i]=out_p[i+1];
                out_p[i+1]=x;
                flag++;
                }
            }//else
        }// for(i)
    if (flag==0)
        break;

    }// for(n)

    return (0);
}



void WINAPI s_tune()
{
}

int WINAPI fu_sm(fy)
BYTE fy;
{
    switch(fy){
        case 1:
            return('Z');
        case 2:
            return('S');
        case 3:
            return('C');
        default:
            return(fy);
    }
}



/**********************************************
find_one_hi()
***********************************************/
int WINAPI find_one_hi()
{
    WORD foh_save=0;
    int i;

    if (!cmp_bx)
        if (cmp_state&4)
            return(0);

    sImeG.cp_ajust_flag=0;

    i=0;
    do{
        if (czcx(&tmmr.stack1[i])){
            if (!foh_save)
                foh_save=cmp_cisu;
            else{
                if (foh_save==cmp_cisu){
                    sImeG.cp_ajust_flag=1;
                    result_area[result_area_pointer++]=LOBYTE(cmp_cisu);
                    result_area[result_area_pointer++]=HIBYTE(cmp_cisu);
                    return(0);
                    }//if (foh_save)
                }//else
            }//if (czcx)
        i++;
      }while(i<(sizeof tmmr.stack1)/2);     //94.1 add div 2

      return (0);
}

/*************************************************
czcx()
**************************************************/
int WINAPI czcx(stack)
WORD *stack;
{

        cmp_cisu=stack[0];

        if (!cmp_cisu)
            return(STC);

        if (cmp_bx)
            if (HIBYTE(cmp_cisu)&0x40)
                cmp_cisu&=0xbfff;

        if (cmp_a_slbl_with_bx())
            return(CLC);

        return(STC);

}

/********************************************
find_multy_hi()
*********************************************/
int WINAPI find_multy_hi()
{
    if (word_long==2)
        find_two_hi();
    if (word_long==3)
        find_three_hi();
    return(0);

}

/********************************************
find_two_hi()
*********************************************/
int WINAPI find_two_hi()
{
    int i,j;
    WORD *result_p;

    result_p=(WORD *)result_area;

    for (i=0; i<(sizeof tmmr.stack2)/(2*2); i=i+2){    //94.1 add *2
        if (!tmmr.stack2[i]){
            sImeG.cp_ajust_flag=0;
            return(0);
            }

        if (cmp_2_and_3(&tmmr.stack2[i])){
            sImeG.cp_ajust_flag=1;
            for (j=0; j<word_long; j++)
                result_p[result_area_pointer/2+j]=tmmr.stack2[j+i]&0xbfff;
            result_area_pointer+=word_long*2;
            return(0);
            }//if
        }//for

    sImeG.cp_ajust_flag=0;
    return(0);

}

/********************************************
find_three_hi()
*********************************************/
int WINAPI find_three_hi()
{
    int i,j;
    WORD *result_p;

    result_p=(WORD *)result_area;

    for (i=0; i<(sizeof tmmr.stack3)/(3*2); i=i+3){    //94.1 add *2
        if (!tmmr.stack3[i]){
            sImeG.cp_ajust_flag=0;
            return(0);
            }

        if (cmp_2_and_3(&tmmr.stack3[i])){
            sImeG.cp_ajust_flag=1;
            for (j=0; j<word_long; j++)
                result_p[result_area_pointer/2+j]=tmmr.stack3[j+i]&0xbfff;
            result_area_pointer+=word_long*2;
            return(0);
            }// if (cmp_2_and_3)
        }//for

    sImeG.cp_ajust_flag=0;
    return(0);

}

/***********************************************
cmp_2_and_3()
************************************************/
int WINAPI cmp_2_and_3(t_stack)
WORD *t_stack;
{
    int i,yj_p;

    yj_p=wp.xsyjw;                          //1993,10,8
    for (i=0; i<word_long; i++){
        cmp_cisu=t_stack[i];
        pre_cmp((WORD)yj_p);
        if (word_long==2)
            if (cmp_state&4)
                if (!(HIBYTE(cmp_cisu)&0x40))
                    return(STC);
                else
                    cmp_cisu&=0xbfff;

        if (!cmp_a_slbl_with_bx())
            return(STC);
        yj_p++;
        }
    return(CLC);

}


void WINAPI find_that()
{
}

int WINAPI find_hz(x)
WORD x;
{
    if (x>0xa000 || x<0x2020)
        return(x);

    if (x>=0x8000){
        x=(x-0x8000)+1;
        return(cisu->t_bf2[x]);
        }

    return((x-0x2020)/94+0xb0+((x-0x2020)%94+0xa1)*0x100);


}

/*************************************************
prepare_search1()
**************************************************/
int WINAPI prepare_search1()
{
    BYTE f_ci1,f_ci2,x;

    f_ci1=wp.syj[wp.xsyjw];
    f_ci2=wp.syj[wp.xsyjw+1];
    f_ci1=(BYTE)fu_sm(f_ci1);
    f_ci2=(BYTE)fu_sm(f_ci2);

    if(f_ci1<0x41)
        f_ci1=0x41;
    if (word_long>=5)
        f_ci2=(BYTE)word_long;

    search_and_read(f_ci1,f_ci2);
//
// After reading, counting the search place is needed
// First, count the STD dictionary buffers
//
    search_start=6;
    search_end=6;
    if (word_lib_state&1){
        x=word_long-2;
        if (x>=3){
            x-=3;
            search_start+=4;}

        if (x>0)
             {
            if (sizeof lib_w<lib_w[x-1])
                search_start=sizeof lib_w;
            else
                search_start=lib_w[x-1];
            }

        search_end=lib_w[x];
        if (sizeof lib_w<search_end)
            search_end=sizeof lib_w;

        }//if (word_lib_state)

 //
 // Second, count the User dic. area.
 //

    kzk_search_start=6;
    kzk_search_end=6;
    if (!(word_lib_state&2))                //Note exp: !word...&2
        return(1);                      // and !(word&2)

    x=word_long-2;
    if (x>=3){
        x-=3;
        kzk_search_start+=4;}

    if (x>0)
        {
        if (sizeof kzk_lib_w<kzk_lib_w[x-1])
            kzk_search_start=sizeof kzk_lib_w;
        else
            kzk_search_start=kzk_lib_w[x-1];
        }

    kzk_search_end=kzk_lib_w[x];
    if (sizeof kzk_lib_w<kzk_search_end)
        kzk_search_end=sizeof kzk_lib_w;

    return (0);
}


/********************************************
search_and_read()
    entry: LOBYTE(f_ci)=the first letter,
           HIBYTE(f_ci)=the second letter,
    exit:  NC success; C not success;
**********************************************/
int WINAPI search_and_read(f_ci1,f_ci2)
BYTE f_ci1,f_ci2;
{
    if (if_already_in(f_ci1,f_ci2))
        return(0);

    count_basic_pera(f_ci1,f_ci2);
    if (item_length!=0)
        if (read_a_page(0,r_addr,item_length))
            word_lib_state=word_lib_state|1;
    read_kzk_lib();

    return (1);
}

/***************************************************************
if_already_in():        adjust if the page has already in the memory
*****************************************************************/
int WINAPI if_already_in(f_ci1,f_ci2)
BYTE f_ci1,f_ci2;
{
    WORD x;

    (BYTE)x=f_ci2;
    x=x*0x100+f_ci1;

    if (x==last_item_name)
        return(CLC);

    if (f_ci1==(BYTE)last_item_name)
        if (f_ci2>9)
            return(STC);
        else
            if (HIBYTE(last_item_name)>9)
                return(STC);
            else
                return(CLC);

    return(STC);

}

/********************************************************
count_basic_pera():     count the sub_library address;
                    count the page address;
                    count the read_write length;
********************************************************/
int WINAPI count_basic_pera(f_ci1,f_ci2)
BYTE f_ci1,f_ci2;
{
    BYTE x;

    word_lib_state=0;
    item_addr=0xffff;
    item_length=0;
    (BYTE)last_item_name=f_ci2;
    last_item_name=last_item_name*0x100+f_ci1;

    if (f_ci1>'I'&& f_ci1<'U')
        slib_addr=(f_ci1-0x41-1)*27;
    else
        if (f_ci1>'V')
            slib_addr=(f_ci1-0x41-3)*27;
        else
            slib_addr=(f_ci1-0x41)*27;

    r_addr=ndx.dir[slib_addr+1];
    r_addr+=ndx.body_start;
    r_addr=r_addr*16;

    if (f_ci2<'A')
        item_addr=slib_addr+MORE_THAN_5;
    else
        if (f_ci2>'I' && f_ci2<'U')
            item_addr=slib_addr+(f_ci2-0x41-1);
        else
            if (f_ci2>'V')
                item_addr=slib_addr+(f_ci2-0x41-3);
            else
                item_addr=slib_addr+(f_ci2-0x41);

    r_addr=r_addr+ndx.dir[item_addr+1+1];
    item_length=ndx.dir[item_addr+1+1+1];
    item_length-=ndx.dir[item_addr+1+1];
    return(0);

}

/***********************************************************
read_kzk_lib(): search the expended lib
************************************************************/
int WINAPI read_kzk_lib()
{
    r_addr=kzk_ndx.dir[slib_addr+1];
    r_addr+=kzk_ndx.body_start;
    r_addr=r_addr*16+KZK_BASE;
    r_addr=r_addr+kzk_ndx.dir[item_addr+1+1];
    kzk_item_length=kzk_ndx.dir[item_addr+1+1+1];
    item_length-=kzk_ndx.dir[item_addr+1+1];
    if (kzk_item_length<0)
        kzk_item_length=0;
    if (!kzk_item_length)
        return(STC);
    if (!read_a_page(1,r_addr,kzk_item_length))
        return(STC);
    word_lib_state|=2;
    return(CLC);

}


///////////////////////////////////////////////////////////////////////////
//     ���ʿ�             READ_A_PAGE()                                  //
//     ����: ����Ҫ�Ĵʿ�ҳ����ָ���Ļ�����                              //
//     ����: START_PS  ���ʿ�����ʼλ��                                  //
//           FILE_FLAG  =0  ����׼��                                     //
//                      =1  ��չ��                                       //
//           SIZE       ����ҳ��(�ֽ���)                                 //
//     ����: TRUE  �ɹ�                                                  //
//           FALSE ʧ��                                                  //
//     ע��:������Ҫ�ж�SIZE�Ĵ�С�Ƿ�Խ��,�Է�ֹ����.                   //
//          ����Խ��,�����ջ������Ĵ�С�ض�.                             //
///////////////////////////////////////////////////////////////////////////

int WINAPI read_a_page(file_flag, start_ps, size)
BYTE file_flag;
LONG start_ps;
WORD size;
{
// 94/4/16 HANDLE hd;
int hd = -1;

if ((last_flag==file_flag)&&(last_start_ps==start_ps)&&(last_size==size))
       return(1);
        //���ζ�д���ʹ���ȫ��ͬ,�����������̲���;



if (file_flag==0)
{
     if (size> sizeof lib_w) size=sizeof lib_w;
     hd=OpenFile(std_dct,&openbuf,OF_READ);
     if (hd == -1) return(0);
     _llseek(hd,start_ps,0);
     if(_lread(hd,(LPSTR)lib_w,size)<=0)
     {
     _lclose(hd);
     return(0);
     }
}


if (file_flag==1)
{
     hd=OpenFile(user_lib,&openbuf_kzk,OF_READ);
     if (hd == -1) return(0);
     if (size>sizeof kzk_lib_w) size=sizeof kzk_lib_w;
             //�жϻ������Ƿ�Խ������

     _llseek(hd,start_ps,0);
     if(_lread(hd,(LPSTR)kzk_lib_w,size)<=0)
     {
    _lclose(hd);
    return(0);
     }
}

if ( hd != -1 )
  _lclose(hd);

last_flag=file_flag;
last_start_ps=start_ps;   // ����������
last_size=size;
return(1);
}

/**********************************************************************
Name:     abbr_s1()
Popurse:  Find match words arrcoding to the given input message.
      Search order is:
            Temp_rem area
            Standard Dictionary
            User Dictionary
      If there are more than one words, judge what is the
         suitable one.

**********************************************************************/
int WINAPI abbr_s1()
{
    group_no=0;
    msx_area_cnt=0;
    out_svw_cnt=0;

    find_new_word();                                    // Search temp rem_area

    abbr_entry((BYTE *)kzk_lib_w+kzk_search_start,(BYTE *)kzk_lib_w+kzk_search_end,4);
                        // Search User dic.
    abbr_entry((BYTE *)lib_w+search_start, (BYTE *)lib_w+search_end,0);
                        // Search stndard dic.

    if (!group_no) return(STC);                 // Without any results...
    if (group_no==1) return(CLC);          // Only one!

    order_result2();                                    // Results more than one...
    if (sImeG.auto_mode) find_multy_hi();     // If in frenquency ajust mode...
     return(CLC);                        // Return OK.
}

/********************************************************
find_new_word()
*********************************************************/
void WINAPI find_new_word()
{
    fczs1((LPSTR)tmmr.temp_rem_area,sizeof tmmr.temp_rem_area,2);
    fczs1((LPSTR)tmmr.rem_area,sizeof tmmr.rem_area,0x82);

}

/*****************************************************
fczs1()
******************************************************/
int WINAPI fczs1(rem_p,end,area_flag)
BYTE *rem_p;                                        //92-12-18 SZ
int end,area_flag;
{
    int i=0,w_long,j;
    WORD *p;

    w_long=word_long*2;

    while(i<end){
        if (w_long==rem_p[i]){
            if (find_long_word2(&rem_p[i])){
                group_no+=1;
                if (!trs_new_word(i,&rem_p[i],area_flag))         //
                    return(0);
            }// if (find_long_word2)
            }// if (w_long)

        if (rem_p[i]==0)
            return(0);

        if (rem_p[i]>18||(rem_p[i]&1)){
            p=(WORD *)&rem_p[i];
            for (j=0; j<(end-i)/2; j++){       //94.2.3 ZHU  (end-i)/2
                if (p[j]!=0)
                    p[j]=0;
                else
                    return(0);
                }// for
            }//if (rem_p)

        i+=rem_p[i]+2;

        }//while

  return (0);
}

/************************************************
find_long_word2()
*************************************************/
int WINAPI find_long_word2(buffer)
BYTE *buffer;
{
    int yj_p,i;

    yj_p=wp.xsyjw;
    for (i=0; i<word_long*2; i=i+2){
        cmp_cisu=buffer[i+2]+buffer[i+2+1]*0x100;
        pre_cmp((WORD)yj_p);
        if (!cmp_a_slbl_with_bx())
            return(STC);
        yj_p++;
        }

    return(CLC);

}


/*************************************************
trs_new_word()
**************************************************/
int WINAPI trs_new_word(word_addr,buffer,area_flag)
int word_addr,area_flag;
BYTE *buffer;
{
    int i;

    if (out_svw_cnt>=sizeof out_svw){
        group_no--;
        return(STC);
        }// if (out_svw_cnt)

    for (i=0;i<word_long*2; i++)
        out_svw[out_svw_cnt++]=buffer[i+2];

    msx_area[msx_area_cnt].pindu=0x70+(BYTE)group_no;
    msx_area[msx_area_cnt].from=(BYTE)area_flag;                  //come from temp_area
    msx_area[msx_area_cnt].addr=(WORD)word_addr;
    if (buffer[1]&0x80)
        msx_area[msx_area_cnt].pindu=0x31;

    msx_area_cnt++;

    return(CLC);
}

/****************************************
pre_cmp()
*****************************************/
void WINAPI pre_cmp(x)
WORD x;
{
    cmp_yj=wp.yj[x];
    cmp_head=wp.syj[x];
    cmp_state=wp.cmp_stack[x];
    cmp_bx=wp.bx_stack[x];
}

/******************************************
cmp_a_slbl_with_bx()
*******************************************/
int WINAPI cmp_a_slbl_with_bx()
{
    if (cmp_cisu<0x2020)
        return(STC);

    if (cmp_cisu>=0x8000){
        if ((cmp_cisu-0x8000)>=cisu->t_bf_start[2]/2)
            return(STC);}
    else{
        if ((cmp_cisu-0x2020)>=cisu->t_bf_start[1]/2)
            return(STC);}

    if (!cmp_a_slbl())
        return(STC);

    if (!cmp_bx)
        return(CLC);


    if (!yjbx())
        return(STC);

    return(CLC);

}

/*******************************************
cmp_a_slbl()
********************************************/
int WINAPI cmp_a_slbl()
{

    if (cmp_state&2)  {

        if (cmp_cisu>=0x8000){
            if (cmp_yj==cisu->t_bf2[cmp_cisu-0x8000])
                return(CLC);
            else
                return(STC);
                //??               return(cmp_first_letter());
            } //if (cmp_cisu...

        else{
            if (cmp_yj==cisu->t_bf1[cmp_cisu-0x2020])
                return(CLC);
            else
                return(STC);
            }//else
      }// if (cmp_state...

    return(cmp_first_letter());

}

/************************************************
cmp_first_letter()
*************************************************/
int WINAPI cmp_first_letter()
{
    WORD py_nm;
    if (!(cmp_state&4))                             //NOte!!!
        return(STC);

    py_nm=(WORD)cisu_to_py();
    if ((HIBYTE(py_nm)&0x5f)==cmp_head)
        return(CLC);
    else{
        py_nm=(WORD)get_head(HIBYTE(py_nm));
        if ((LOBYTE(py_nm)&0xdf)==cmp_head)
            return(CLC);
        else
            return(STC);
        }

}

/***********************************************
cisu_to_py()
************************************************/
int WINAPI cisu_to_py()
{
    if (cmp_cisu>=0x8000)
        return(cisu->t_bf2[(cmp_cisu-0x8000)]);
    else
        return(cisu->t_bf1[(cmp_cisu-0x2020)]);
                
}

/**************************************************
get_head()
***************************************************/
int WINAPI get_head(first_letter)
BYTE first_letter;
{
    if (first_letter>=0x41)
        return(first_letter);
    
    first_letter=(first_letter-1)*5;
    return(slbl_tab[first_letter]);
    
}

/******************************************************
yjbx()
*******************************************************/
int WINAPI yjbx()
{
    BYTE bx;
    WORD pos;

    if (cmp_cisu<0x8000)
           pos = cmp_cisu-0x2020;
    else{
        pos =cisu->t_bf2[(cmp_cisu-0x8000)+1];
        pos =(HIBYTE(pos)-0xa1)+(LOBYTE(pos)-0xb0)*94;
        }
    if (pos>= 94*94)  return (STC);
    bx=spbx_tab[pos];
    if (cmp_bx==bx)
        return(CLC);
    else
        if (cmp_bx==(bx&0xf0))
            return(CLC);
        else
            return(STC);

}


/****************************************************
abbr_entry()
*****************************************************/
int WINAPI abbr_entry(s_start,s_end,ComeFrom)
BYTE *s_start,*s_end,ComeFrom;                                                   //Search start and Ending

{                                                                                               // position
int i;

    while (s_start<s_end){
        if (cmp_long_word2(s_start)){                                    //Compare word by word.
            if (out_svw_cnt>=sizeof out_svw)    // If buffer out_svw
                                //   is full, sorry... 
                return(STC);
                for (i=0; i<word_long*2; i++)   
                    out_svw[out_svw_cnt++]=s_start[i];  //Move the words    

                msx_area[msx_area_cnt].pindu=s_start[i];
                msx_area[msx_area_cnt].from=ComeFrom; //come from ...
                msx_area[msx_area_cnt].addr=(WORD)s_start; // Where is the ...

                msx_area_cnt++;                  // Increae the pointer 
                                 // for the attribue area
    
            group_no+=1;                                            // In case of OK, increaase 
                                                // results counter.
        }//if(cmp..                 
        
         s_start+=(word_long+word_long+1);          // Push down the search pointer
                            // by word_long*2+1 
        }

    return(CLC);                                                            // The value of return is no
                            // use for the route.
}

/******************************************************
cmp_long_word2()
*******************************************************/
int WINAPI cmp_long_word2(buffer)
BYTE *buffer;
{
    int yj_p,i;
    
    yj_p=wp.xsyjw;
    for (i=0; i<word_long*2; i=i+2){
        cmp_cisu=buffer[i]+buffer[i+1]*0x100;
        if (cmp_cisu<0x2020)
            return(STC);
        pre_cmp((WORD)yj_p);
        if (!cmp_a_slbl_with_bx())
            return(STC);
        yj_p++;
        }
    
    return(CLC);
            
}

/*******************************************************
order_result2()
********************************************************/
int WINAPI order_result2()
{
    int lng,i,j,n;
    BYTE x,flag;
    WORD y;

    lng=word_long*2;
    if (xs_flag==1){
        xs_flag=0;
        if (!fenli_daxie())
        return(0);
        }

    if (msx_area_cnt==1)
        return(0);


    for (i=group_no-1; i>0; i--){
        flag=0;
    for (j=0; j<i; j++){
        if (msx_area[j].pindu<msx_area[j+1].pindu){
            for (n=j*lng; n<j*lng+lng; n++){
                x=out_svw[n];
                out_svw[n]=out_svw[n+lng];
                out_svw[n+lng]=x;
                }//for
            x=msx_area[j].pindu;
            msx_area[j].pindu=msx_area[j+1].pindu;
            msx_area[j+1].pindu=x;
            x=msx_area[j].from;
            msx_area[j].from=msx_area[j+1].from;
            msx_area[j+1].from=x;
            y=msx_area[j].addr;
            msx_area[j].addr=msx_area[j+1].addr;
            msx_area[j+1].addr=y;
            flag=1;

        }// if (msx)
         }//for(j)
         
         if (!flag)
        break;
    }// for(i)


    return (0);

}

/*****************************************************
fenli_daxie()
******************************************************/
int WINAPI fenli_daxie()
{
    int i,j,n,lng;

    j=0;
    lng=word_long*2;
    for (i=0; i<msx_area_cnt; i++){
        if (msx_area[i].pindu==0x31){
            msx_area[j].pindu=msx_area[i].pindu;
            msx_area[j].from=msx_area[i].from;
            msx_area[j].addr=msx_area[i].addr;
            for (n=0; n<lng; n++)
                out_svw[j*lng+n]=out_svw[i*lng+n];
            j++;                                                                            
            }//if
        }// for
    
    if (!j)
        return(CLC);            // there is no Caps;
    group_no=j;
    return(STC);                    // there has Caps;

}
    
/*************************************************
rzw()
**************************************************/
int WINAPI rzw()
{
    if (!(system_info&1))           //if strength mode, ret
        sfx_proc();
    return(0);
    
}

/************************************************
abbr()
*************************************************/
int WINAPI abbr()
{
    int i;
    WORD x;
    WORD *kbf_p;
    
    if (in.true_length<2){
        xs_flag=1;
        jiyi_pindu|=0x80;
        return(0);              
        }

    for (i=0; i<in.true_length; i++){
        if (in.buffer[i]&0x20){                 //if not Caps
            xs_flag=1;
            jiyi_pindu|=0x80;
            return(0);
            }// if 
        }//for
    
    kbf_p=(WORD *)kbf.buffer;
    x=0x2d*0x100;
        
    kbf.true_length=in.true_length*2;
    for (i=0; i<in.true_length; i++){
        (BYTE)x=in.buffer[i];
        *(LPUNAWORD)&kbf_p[i]=x;                
        }
    kbf.buffer[in.true_length*2]=0;
    in.info_flag=VK_MULTIPLY;
    return(0);
        
}


/***************************************************
sfx_proc()
****************************************************/
int WINAPI sfx_proc()
{
    int i,j;
    WORD x,save_xsyjw;
    WORD *result_p;
    BYTE *sfx_p;

    result_p=(WORD *)result_area;
    sfx_p=(BYTE *)sfx_table;
    
    if (sImeG.cp_ajust_flag==1)
        return(0);
    if (word_long>=3)
        return(0);

    save_xsyjw=(WORD)wp.xsyjw;
    wp.xsyjw=wp.xsyjs;
    
    i=0;
    do{
        x=sfx_table[i];
        if (HIBYTE(x)&sfx_attr)
            if (LOBYTE(x)==word_long*2)
                if (cmp_long_word2(&sfx_p[i*2+2])){
                    for (j=0; j<word_long; j++)
                         result_p[result_area_pointer/2+j]=sfx_table[i+1+j];
                    result_area_pointer+=word_long*2;
                    wp.xsyjw=save_xsyjw;
                    sImeG.cp_ajust_flag=1;
                    return(0);
                    }//if (cmp_...
        
        i+=LOBYTE(x)/2+1;

        }while(i<sfx_table_size);
            
    wp.xsyjw=save_xsyjw;

    return (0);
    
}


void WINAPI zdyb()
{
}

/************************************************
recall_rc()
*************************************************/
int WINAPI recall_rc()
{
    int i;
    BYTE x;

    word_long=wp.yjs-wp.xsyjw;
    unit_length=word_long*2;
            
    i=0;
    do{
        x=logging_stack[i];
        if (!x)
            break;
        if (word_long*2>x)
            i+=x+1;
        else{
            if (x>20)                       //if more than 10 chinese words?
                break;
            if ((i+x)>=logging_stack_size)                  
                break;                  //if the last word is not completely
            if (find_long_word3((WORD *)&logging_stack[i+1],(int)(x/2))){
                trs_new_word3(x,i);
                group_no++;
                if (group_no>5)
                    break;
                }
            i+=x+1;
            }//else
        }while(i<logging_stack_size);
    
    if (group_no){
        word_long=4;
        unit_length=8;
        return(CLC);
        }
            
    return(STC);                            
}

/*********************************************
find_long_word3()
**********************************************/
int WINAPI find_long_word3(stack,length)
WORD *stack;
int length;
{
    int yj_p,i,err_flg,m;
    
    
    yj_p=wp.xsyjw;
    
    m=0;
    while ((length-m)>=word_long){
        err_flg=0;
        for (i=0; i<word_long; i++){
            cmp_cisu=stack[m+i];
            pre_cmp((WORD)(yj_p+i));
            if (!cmp_a_slbl_with_bx()){
                m++, err_flg=1;
                break;
                }
            }//for
        if (!err_flg)
            return(CLC);
            
        }
    return(STC);
        
}


/*************************************************
trs_new_word3()
**************************************************/
void WINAPI trs_new_word3(length,addr)
int addr;
BYTE length;
{
    int cnt,i;
    char *msx_area_p;

    cnt=8*group_no;
    
    msx_area_p=(BYTE *)msx_area;
    msx_area_p[22*group_no]=length;
    addr++;
    for (i=0; i<length; i++)
        msx_area_p[22*group_no+1+i]=logging_stack[addr+i];                                              
    for (i=0; i<8; i++)
        out_svw[cnt+i]=0xa1;
    if ((length/2)<=4){
        for (i=0; i<length; i++)
            out_svw[cnt+i]=logging_stack[addr+i];
        }
    else{
        for (i=0; i<4; i++)
            out_svw[cnt+i]=logging_stack[addr+i];
        out_svw[cnt+i]=0xa1,i++;
        out_svw[cnt+i]=0xad,i++;
        out_svw[cnt+i]=logging_stack[addr+length-2],i++;
        out_svw[cnt+i]=logging_stack[addr+length-1],i++;
        }

}

/******************************************************
new_word():
*******************************************************/
int WINAPI new_word()
{
    WORD temp_save,suc_flag,i,j;

    by_cchar_flag=0;
    wp.xsyjw=0;
    temp_save=sImeG.cp_ajust_flag;

    suc_flag=0;

    if (convert(0)){
        sImeG.cp_ajust_flag=(BYTE)temp_save;
        if (unit_length==new_no){
            for (i=0; i<group_no; i++){
                suc_flag = 0;        //1993 11 4
                for(j=0; j<new_no; j++){
                    if (result_area[j]!=out_svw[i*unit_length+j])
                        suc_flag=1;
                    }//for(j)
                if (!suc_flag){
                    return(0);}
                }//for(i)
            }//if (unit_length)
        }//if(convert)

    sImeG.cp_ajust_flag=(BYTE)temp_save;
    by_cchar_flag=1;
    return(rem_new_word());

}


/***********************************************************
rem_new_word(): fill the new word in temp_rem_area
************************************************************/
int WINAPI rem_new_word()
{
    WORD i,count;                            //SZ
    WORD *result_area_p;

    count=(WORD)( (sizeof tmmr.temp_rem_area)-(new_no+2) );  //92-12-18 SZ
    CopyMemory/*memmove*/(&tmmr.temp_rem_area[(new_no+2)/2],
        tmmr.temp_rem_area,
        count);

    tmmr.temp_rem_area[0]=new_no+jiyi_pindu*0x100;

    result_area_p=(WORD *)result_area;
    for (i=0; i<new_no/2; i++)
        tmmr.temp_rem_area[i+1]=result_area_p[i];

    write_new_word(1);
   
    return(0);

}

/**********************************************************************
 Function: AddExtLib()
 Purpose:  Get a temperary rem word into high level depanding
       how many times it has been used.
  Entry:   Must be called from out_result.
  Out  :   None.
***********************************************************************/
int WINAPI AddExtLib(){
 
    int x,count,i;


    if((unit_length>=4)&&(unit_length<=18))  //rem word limited
         if(msx_area[current_no].from==2)
         {     // If a rem word?
            x=msx_area[current_no].addr/2;     //get word addr in temp...

            if (x<sizeof tmmr.temp_rem_area/2)
            {   //Insure random errof out limited
                if ((tmmr.temp_rem_area[x]&0xff)!=unit_length)
                        return(STC);

               tmmr.temp_rem_area[x]+=0x100;    //Increase used times.

               if((tmmr.temp_rem_area[x]&0xf00)>=0x300)
               {                            
                  count=(sizeof tmmr.rem_area)
                          -(unit_length+2);     // Push down middle rem area
                  CopyMemory(&tmmr.rem_area[(unit_length+2)/2],
                            tmmr.rem_area,
                            count);

                  for(i=0; i<unit_length/2+1; i++)
                     tmmr.rem_area[i]=tmmr.temp_rem_area[x+i]; 
                                       //move to middle rem area.

                  count=sizeof tmmr.temp_rem_area-x*2
                         -(unit_length+2);   //delete it from temp ...
                  CopyMemory(&tmmr.temp_rem_area[x],
                             &tmmr.temp_rem_area[x+unit_length/2+1],
                             count);

                  write_new_word(0);
                  if(tmmr.rem_area[50])   //[400])          //1994.4.21
                  {
                    UpdateProc();
                  }
               }                //write changes
               else
                  write_new_word(1);
            }

         }

    return (0);
}

/********************************************************
write_new_word():
*********************************************************/
void WINAPI write_new_word(flag)
int flag;
{
    int count;
    LONG distance;
    WORD *p;

    distance=sizeof tmmr.stack1+sizeof tmmr.stack2+sizeof tmmr.stack3;
    count=sizeof tmmr.temp_rem_area;
    p=tmmr.temp_rem_area;

    if (flag!=1){
        distance=sizeof tmmr.stack1+sizeof tmmr.stack2
                    +sizeof tmmr.stack3+sizeof tmmr.temp_rem_area;
        p=tmmr.rem_area;
        if (flag<1){
            distance=sizeof tmmr.stack1
                 +sizeof tmmr.stack2
                 +sizeof tmmr.stack3;       //92-12-18 SZ
            p=tmmr.temp_rem_area;
            count=(sizeof tmmr.temp_rem_area)+(sizeof tmmr.rem_area);
            }
        }

    writefile(tmmr_rem,distance,(LPSTR)p,count);


}

/*******************************************************
writefile(): write file in disk
********************************************************/
int WINAPI writefile(file_n,distance,p,count)
BYTE *file_n;
LONG distance;
LPSTR p;                                   //WORD *p;
int count;
{
    int hd;
    int write_c;

    hd=OpenFile(file_n,&open_tmmr,OF_WRITE);
    if (hd==-1) return(STC);

    _llseek(hd,distance,0);
    write_c=_lwrite(hd,(LPSTR)p,count);
    if (write_c!=count)
    {
       _lclose(hd);
       return(STC);
    }
    hd=_lclose(hd);
    return(CLC);
}

/***************************************************************
look_for_code(): search if the code is in the index
****************************************************************/
int WINAPI look_for_code()
{
    int i,rec_cnt;

    rec_cnt=0;
    for (i=0x10; i<(mulu_true_length+0x10); i=i+mulu_record_length){
        if (if_code_equ(i))
            return(rec_cnt+1);   //find the code, rec_cnt+1 in order to avoid
        else                     //confusing with STC
            rec_cnt++;
        }
    return(STC);                 // not found

}


/**************************************************************
read_data(): read the record correspond to the code
***************************************************************/
int WINAPI read_data(rec_cnt)
int rec_cnt;
{
    int hd;
    int op_count;

    hd=OpenFile(user_lib,&open_user, OF_READ);
    if (hd==-1)
        return(FALSE);
    _llseek(hd,(data_start+rec_cnt*data_record_length), 0);
    op_count=_lread(hd,(LPSTR)&out_svw,data_record_length);
    if (op_count!=data_record_length)
    {
        _lclose(hd);
        return(FALSE);
    }
    _lclose(hd);

    if (out_svw[0]<2)
        return(STC);
    if ((out_svw[0]-0x30)>30)
        return(STC);

    return(CLC);

}

int WINAPI UpdateProc()
{


         UpdateFlag=1;
         ExeCmdLine[ParaPos]='7';
         WinExec(ExeCmdLine,SW_SHOW);
         return(0);

}


/***********************************************
rem_pd1()
************************************************/
int WINAPI rem_pd1(buffer)
WORD *buffer;
{
    WORD temp;                     

    temp=buffer[0];                 

    if (wp.bx_stack[wp.xsyjs])
        temp|=0x4000;           
    else
        if (wp.cmp_stack[wp.xsyjs]==4)
            return(0);

    push_down_stack1();

    tmmr.stack1[0]=temp;            
    return(0);

}

/**********************************************
push_down_stack1()
***********************************************/
int WINAPI push_down_stack1()
{
    int i;

    i=(sizeof tmmr.stack1-2);                 

    CopyMemory/*memmove*/((BYTE *)&tmmr.stack1[1],(BYTE *)&tmmr.stack1[0],i);
    stack1_move_counter++;
    if (stack1_move_counter>=4)
        writefile(tmmr_rem, 0l, (LPSTR)&tmmr.stack1, sizeof tmmr.stack1);
    return(0);

}

/***********************************************
rem_pd2()
************************************************/
void WINAPI rem_pd2(buffer)
WORD *buffer;
{

    WORD temp1,temp2;                       

    int i;

    temp1=buffer[0], temp2=buffer[1];       

    if (wp.cmp_stack[wp.xsyjs]!=2)
        temp1|=0x4000;                   
    if (wp.cmp_stack[wp.xsyjs+1]!=2)
        temp2|=0x4000;                   

    i=(sizeof tmmr.stack2-4-4);       
    CopyMemory/*memmove*/((BYTE *)&tmmr.stack2[2],(BYTE *)&tmmr.stack2[0],i);
    tmmr.stack2[0]=temp1;                    
    tmmr.stack2[1]=temp2;                    
    writefile(tmmr_rem, (LONG)sizeof tmmr.stack1,
                (LPSTR)&tmmr.stack2, sizeof tmmr.stack2);


}

/***********************************************
rem_pd3()
************************************************/
void WINAPI rem_pd3(buffer)
WORD *buffer;
{
    int i;
    i=(sizeof tmmr.stack3-6);                       
    CopyMemory/*memmove*/((BYTE *)&tmmr.stack3[3],(BYTE *)&tmmr.stack3[0],i);
    for (i=0; i<3; i++)
    tmmr.stack3[i]=buffer[i];
    writefile(tmmr_rem, (LONG)(sizeof tmmr.stack1+sizeof tmmr.stack2),
                (LPSTR)&tmmr.stack3, sizeof tmmr.stack3);

}

//this module is come from ABCWIN.EXE
INT_PTR CALLBACK ImeAboutDlgProc(
    HWND   hDlg,                         /* window handle of the dialog box */
    UINT   message,                      /* type of message                 */
    WPARAM wParam,                       /* message-specific information    */
    LPARAM lParam
    )
{
    RECT rc;
    LONG DlgWidth, DlgHeight;

    switch (message) {
    case WM_INITDIALOG:                /* message: initialize dialog box */
        hCrtDlg = hDlg;            
        CenterWindow(hDlg);

    return (TRUE);          // don't want to set focus to special control

    case WM_CLOSE:
        EndDialog(hDlg, TRUE);  
        return (TRUE);

    case WM_PAINT:
        {
        RECT Rect;
        HDC hDC;  
        PAINTSTRUCT ps;

        GetClientRect(hDlg, &Rect);         //get the whole window area
        InvalidateRect(hDlg, &Rect, 1);
        hDC=BeginPaint(hDlg, &ps);


       // FillRect(hDC, &Rect, GetStockObject(LTGRAY_BRUSH)); //paint the whole area
        Rect.left+=10;//5;
        Rect.top+=8;//5;
        Rect.right-=10;//5;
        Rect.bottom-=40;//5;

        DrawEdge(hDC, &Rect, EDGE_RAISED,/*EDGE_SUNKEN,*/ BF_RECT);

        //FrameRect(hDC, &Rect, GetStockObject(WHITE_BRUSH)); //draw the frame
        EndPaint(hDlg, &ps);


        break;      
        }
    case WM_COMMAND:
    switch (wParam) {
    case IDOK:
        EndDialog(hDlg, FALSE);
        break;
    case IDCANCEL:
        EndDialog(hDlg, FALSE);
        break;
    default:
        return (FALSE);
        break;
    }
    return (TRUE);
    }
    return (FALSE);                           /* Didn't process a message    */
}

int CommandProc(WPARAM wParam,HWND hWnd)
 
{

    lpImeL->TempUIWnd = hWnd;
    switch(wParam){
        case IDM_SKL1:
        case IDM_SKL2:
        case IDM_SKL3:
        case IDM_SKL4:
        case IDM_SKL5:
        case IDM_SKL6:
        case IDM_SKL7:
        case IDM_SKL8:
        case IDM_SKL9:
        case IDM_SKL10:
        case IDM_SKL11:
        case IDM_SKL12:
        case IDM_SKL13:
        {
            HIMC           hIMC;
            LPINPUTCONTEXT lpIMC;
            LPPRIVCONTEXT  lpImcP;
            DWORD          fdwConversion;

            hIMC =(HIMC)GetWindowLongPtr(GetWindow(hWnd,GW_OWNER),IMMGWLP_IMC);
            lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC);
            if (!lpIMC) {          
               return (0L);
            }

            lpImcP = (LPPRIVCONTEXT)ImmLockIMCC(lpIMC->hPrivate);
    
            if (!lpImcP) {
               return (0L);
            }

            {
                UINT i;

                lpImeL->dwSKWant = LOWORD(wParam) - IDM_SKL1;
                lpImeL->dwSKState[lpImeL->dwSKWant] = 
                lpImeL->dwSKState[lpImeL->dwSKWant]^1;
            
                // clear other SK State
                for(i=0; i<NumsSK; i++) {
                    if(i == lpImeL->dwSKWant) continue;
                    lpImeL->dwSKState[i] = 0;
                }

                if(lpImeL->dwSKState[lpImeL->dwSKWant]) {
                    if(LOWORD(wParam) == IDM_SKL1)
                        lpImcP->iImeState = CST_INIT;
                    else
                        lpImcP->iImeState = CST_SOFTKB;
                    fdwConversion = lpIMC->fdwConversion | IME_CMODE_SOFTKBD;
                } else {
                    lpImcP->iImeState = CST_INIT;
                    fdwConversion = lpIMC->fdwConversion & ~(IME_CMODE_SOFTKBD);
                }
                
            }
            ImmSetConversionStatus(hIMC, (fdwConversion & ~(IME_CMODE_SOFTKBD)),
            lpIMC->fdwSentence);
            ImmSetConversionStatus(hIMC, fdwConversion, lpIMC->fdwSentence);

            ImmUnlockIMCC(lpIMC->hPrivate);
            ImmUnlockIMC(hIMC);
            break;
        }


        case SC_METHOD0:
            break;
        case SC_METHOD9:
            DoPropertySheet(GetActiveWindow(),hWnd);
            ReInitIme( hWnd , lpImeL->wImeStyle );

            break;
        case SC_METHOD4:

            WinExec("ABCWM.exe", SW_SHOW); 
            break;

        case SC_METHOD6:
            return 0; // 4.20 94

        case SC_METHOD7:
            WinHelp(hWnd,"winabc.hlp", HELP_FINDER ,0l);
            return 0;
        case SC_METHOD8:
            MessageBeep(0);
            return 0;

        case SC_METHOD10:
            {
                HIMC           hIMC;
                LPINPUTCONTEXT lpIMC;
                HWND hUIWnd;

                hUIWnd = GetWindow(hWnd, GW_OWNER);

                if (!hUIWnd) {
                    return (0L);
                }

                hIMC = (HIMC)GetWindowLongPtr(hUIWnd, IMMGWLP_IMC);
                if (!hIMC) {          
                    return (0L);
                }

                lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC);
                if (!lpIMC) {          
                    return (0L);
                }

                DialogBox(hInst,"wfc", lpIMC->hWnd, OpenDlg);

                ImmUnlockIMC(hIMC);
                break;
            }

        case SC_METHODA:
            return(0);

        case SC_ABOUT:
            {
                HIMC           hIMC;
                LPINPUTCONTEXT lpIMC;
                HWND hUIWnd;

                hUIWnd = GetWindow(hWnd, GW_OWNER);

                if (!hUIWnd) {
                    return (0L);
                }

                hIMC = (HIMC)GetWindowLongPtr(hUIWnd, IMMGWLP_IMC);
                if (!hIMC) {          
                    return (0L);
                }

                lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC);
                if (!lpIMC) {         
                    return (0L);
                }

                DialogBox(hInst, "ABOUT", lpIMC->hWnd, ImeAboutDlgProc);

                ImmUnlockIMC(hIMC);
                break;
            }

        default:
            break;
    }
    return 0;
}