Microsoft/WindowsXP-SP1
Microsoft/WindowsXP-SP1
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
master
WindowsXP-SP1/windows/feime/chs/ntabc/winabc/abc95wp.c

5762 lines
152 KiB
C
Raw Permalink Normal View History

First commit
2001-01-01 00:00:00 +01:00
/*************************************************
* 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;
}
Reference in New Issue Copy Permalink