5762 lines
152 KiB
C
5762 lines
152 KiB
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[]="<EFBFBD>Þ£<EFBFBD>";
|
||
|
||
|
||
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);
|
||
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
////////////////////////////////////////////////////////////////////////
|
||
// <20><>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> data_init() //
|
||
// <20><><EFBFBD><EFBFBD>: <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD> //
|
||
// <20><><EFBFBD><EFBFBD> 1. ?MMR.REM //
|
||
// 2. <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>, <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ƶ<EFBFBD>ȱ<EFBFBD>,<2C><><EFBFBD><EFBFBD><EFBFBD>ʻ<EFBFBD><CABB><EFBFBD> //
|
||
// 3. <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>׼<EFBFBD>ʿ<EFBFBD><CABF><EFBFBD><EFBFBD>û<EFBFBD><C3BB>ʿ<EFBFBD><CABF>IJ<EFBFBD><C4B2><EFBFBD>. //
|
||
// 4. <20><><EFBFBD><EFBFBD>TMMR.REM, <20><><EFBFBD><EFBFBD><EFBFBD>û<EFBFBD><C3BB>ʿⲻ<CABF><E2B2BB><EFBFBD><EFBFBD>,<2C><><EFBFBD><EFBFBD>֮. //
|
||
// 5. <20><><EFBFBD><EFBFBD><EFBFBD>û<EFBFBD><C3BB>ʿ<EFBFBD> //
|
||
// <20><><EFBFBD>Ú²<EFBFBD><DAB2><EFBFBD>: <20><> //
|
||
// <20><><EFBFBD>ڲ<EFBFBD><DAB2><EFBFBD>: TURE <20><>ʼ<EFBFBD><CABC><EFBFBD>ɹ<EFBFBD> //
|
||
// FALSE <20><>ʼ<EFBFBD><CABC>ʧ<EFBFBD><CAA7> //
|
||
////////////////////////////////////////////////////////////////////////
|
||
|
||
|
||
void WINAPI data_init()
|
||
{
|
||
|
||
BYTE new_flag=0; //һ<>δ<EFBFBD><CEB4><EFBFBD><EFBFBD>û<EFBFBD><C3BB>ļ<EFBFBD>?
|
||
BYTE the_para='U'; //<2F><><EFBFBD><EFBFBD><EFBFBD>IJ<EFBFBD><C4B2><EFBFBD>
|
||
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; //ȱ<>ٴʿ<D9B4><CABF>ļ<EFBFBD>WINABC.CWD
|
||
char read_ndx_wrong[]=ERR03; //"<22>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>";
|
||
char m_short[]=ERR14; //"<22>Ú´æ²»<DAB4><E6B2BB><EFBFBD><EFBFBD>";
|
||
char no_cw_ovr[]=ERR04; //"ȱ<>ٻ<EFBFBD><D9BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD>WINABC.OVL<56><4C>";
|
||
char jiyi_wenjian_cuo[]=ERR13; //"<22>û<EFBFBD><C3BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>!";
|
||
char TMMR_WRITE_WRONG[]=ERR09; // "<22><><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD>д<EFBFBD><D0B4>";
|
||
|
||
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); // <20><><EFBFBD><EFBFBD>Ö¸<EFBFBD><D6B8>
|
||
|
||
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); // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
|
||
if (op_count!=PTZ_LIB_LENGTH)
|
||
err_exit(ERR06); //"Read WINABC.OVL Wrong!");
|
||
|
||
_llseek((HFILE)hd, PD_START_POINTER, 0); //<2F><><EFBFBD><EFBFBD>Ö¸<EFBFBD><D6B8>
|
||
op_count=_lread((HFILE)hd,(LPSTR)&pindu.pd_bf0,PD_LENGTH); //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ӡ<EFBFBD><D3A1><EFBFBD><EFBFBD>Ƶ<EFBFBD>ȱ<EFBFBD>
|
||
if (op_count!=PD_LENGTH)
|
||
err_exit(ERR06); //("Read WINABC.OVL Wrong!");
|
||
|
||
_llseek(hd, SPBX_START_POINTER, 0); //<2F><><EFBFBD><EFBFBD>Ö¸<EFBFBD><D6B8>
|
||
op_count=_lread(hd,(LPSTR)&spbx_tab,SPBX_LENGTH); // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>α<EFBFBD>
|
||
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 Ŀ¼<C4BF><C2BC>д<EFBFBD><D0B4><EFBFBD>ֽ<EFBFBD>
|
||
0x1800, //MULU_LENGTH_MAX SIZELIB+SIZELIB_KZK Ŀ¼<C4BF><C2BC><EFBFBD>󳤶<EFBFBD>=<3D><><EFBFBD><EFBFBD><EFBFBD>صij<D8B5><C4B3><EFBFBD>
|
||
0x10, //MULU_TRUE_LENGTH 10H Ŀ¼<C4BF><C2BC>ʵ<EFBFBD>ʳ<EFBFBD><CAB3><EFBFBD>,<2C><>ʼֻ<CABC>в<EFBFBD><D0B2><EFBFBD>.
|
||
0xA, //MULU_RECORD_LENGTH 10 Ŀ¼ÿ<C2BC><C3BF><EFBFBD><EFBFBD>¼<EFBFBD>ij<EFBFBD><C4B3>ȡ<EFBFBD>
|
||
0, //DATA_START_HI 0 <20><><EFBFBD><EFBFBD><EFBFBD>û<EFBFBD><C3BB>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>64K֮<4B><D6AE>.
|
||
0x1800, //DATA_START_LOW DW SIZE LIB_W Ŀ¼<C4BF><C2BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ν<EFBFBD>.
|
||
0x20}; //DATA_RECORD_LENGTH 32 ÿ<><C3BF><EFBFBD><EFBFBD>¼<EFBFBD>ij<EFBFBD><C4B3><EFBFBD>.
|
||
|
||
OFSTRUCT ofs;
|
||
int hd,i,count;
|
||
HANDLE hMem;
|
||
LPSTR rem_area,p;
|
||
WORD *pp;
|
||
|
||
char TMMR_OPEN_WRONG[]= ERR07; //"<22><><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD><C4BC>򿪴<EFBFBD>";
|
||
char TMMR_READ_WRONG[]= ERR08; //"<22><><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD>";
|
||
char TMMR_WRITE_WRONG[]=ERR09; // "<22><><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD>д<EFBFBD><D0B4>";
|
||
char USER_OPEN_WRONG[]= ERR10; //"<22>û<EFBFBD><C3BB>ʿ<EFBFBD><CABF>򿪴<EFBFBD>";
|
||
char USER_READ_WRONG[]= ERR11; //"<22>û<EFBFBD><C3BB>ʿ<EFBFBD><CABF><EFBFBD><EFBFBD><EFBFBD>";
|
||
char USER_WRITE_WRONG[]=ERR12; // "<22>û<EFBFBD><C3BB>ʿ<EFBFBD>д<EFBFBD><D0B4>";
|
||
|
||
|
||
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
|
||
|
||
|
||
|
||
//
|
||
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>,ĿǰΪģ<CEAA><C4A3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>, <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϊһ<CEAA><D2BB><EFBFBD>Ի<EFBFBD><D4BB><EFBFBD>
|
||
// <20><><EFBFBD>ص<EFBFBD><D8B5><EFBFBD>Ϣ<EFBFBD><CFA2><EFBFBD><EFBFBD>: 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);
|
||
|
||
}
|
||
|
||
|
||
///////////////////////////////////////////////////////////////////////////
|
||
// <20><><EFBFBD>Ê¿<EFBFBD> READ_A_PAGE() //
|
||
// <20><><EFBFBD><EFBFBD>: <20><><EFBFBD><EFBFBD>Òª<EFBFBD>Ä´Ê¿<C4B4>Ò³<EFBFBD><D2B3><EFBFBD><EFBFBD>Ö¸<EFBFBD><D6B8><EFBFBD>Ä»<EFBFBD><C4BB><EFBFBD><EFBFBD><EFBFBD> //
|
||
// <20><><EFBFBD><EFBFBD>: START_PS <20><><EFBFBD>ʿ<EFBFBD><CABF><EFBFBD><EFBFBD><EFBFBD>ʼλ<CABC><CEBB> //
|
||
// FILE_FLAG =0 <20><><EFBFBD><EFBFBD>×¼<EFBFBD><D7BC> //
|
||
// =1 <20><>Õ¹<EFBFBD><D5B9> //
|
||
// SIZE <20><><EFBFBD><EFBFBD>Ò³<EFBFBD><D2B3>(<28>Ö½<EFBFBD><D6BD><EFBFBD>) //
|
||
// <20><><EFBFBD><EFBFBD>: TRUE <20>ɹ<EFBFBD> //
|
||
// FALSE ʧ<><CAA7> //
|
||
// ע<><D7A2>:<3A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ҫ<EFBFBD>ж<EFBFBD>SIZE<5A>Ĵ<EFBFBD>С<EFBFBD>Ƿ<EFBFBD>Խ<EFBFBD><D4BD>,<2C>Է<EFBFBD>ֹ<EFBFBD><D6B9><EFBFBD><EFBFBD>. //
|
||
// <20><><EFBFBD><EFBFBD>Խ<EFBFBD><D4BD>,<2C><><EFBFBD><EFBFBD><EFBFBD>ջ<EFBFBD><D5BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ĵ<EFBFBD>С<EFBFBD>ض<EFBFBD>. //
|
||
///////////////////////////////////////////////////////////////////////////
|
||
|
||
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);
|
||
//<2F><><EFBFBD>ζ<EFBFBD>д<EFBFBD><D0B4><EFBFBD>ʹ<EFBFBD><CDB4><EFBFBD>ȫ<EFBFBD><C8AB>ͬ,<2C><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>̲<EFBFBD><CCB2><EFBFBD>;
|
||
|
||
|
||
|
||
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;
|
||
//<2F>жϻ<D0B6><CFBB><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ƿ<EFBFBD>Խ<EFBFBD><D4BD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
|
||
_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; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
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
|
||
BOOL CALLBACK ImeAboutDlgProc(hDlg, message, wParam, lParam)
|
||
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,(DLGPROC)ImeAboutDlgProc);
|
||
|
||
ImmUnlockIMC(hIMC);
|
||
break;
|
||
}
|
||
|
||
default:
|
||
break;
|
||
}
|
||
return 0;
|
||
}
|
||
|