able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/windows/feime/chs/ntabc/winabc/abc95wp.c
CryptoAlgo Inc b3cac27891 Add source files
2020-09-26 16:20:57 +08:00

5762 lines
146 KiB
C
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/*************************************************
* 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 a new issue View git blame Copy permalink