在Sco下利用Curses/Form建立簡單的用戶界面(三)

sdccf

在使用表單工作時，有時不希望使用new_field()來一個域一個域地建立表單，這樣做不僅麻煩也不便與修改，每次畫面變更之后還要重新編譯。這里我們采用一個更加通用的方法--建立一個表單格式定義文件，使程序代碼在每次調用表單時都讀取這個文件，搜索指定表單，不用重新編譯，就可以馬上改變畫面。
這個表單定義文件的格式是：
1001*0*聯(lián)機簽到
1001|0|000|柜   員：|12|24||......
1001|0|001||12|32|8|......
1001|0|002|密   碼：|14|24||......
1001|0|003||14|32|8|......
1002*0*修改柜員密碼
......
每個表單在此文件中有一個唯一的主畫面號。比如1001等，幾個副畫面號如0 1 等，在定義時用*分隔；而表單中的每一個域都在此文件中定義，表單域的各特征項如所屬主畫面號、副畫面號、序號、名稱、位置、長度、是否標簽域、是否密碼域、是否返回、所用緩沖區(qū)號、對齊、類型等等都用|分隔。這些時建域時使用的。
要利用此文本文件建域，就需要一些工作：
首先以畫面號、副畫面號來讀取文件中的域定義：
CLFIELDNODE **cl_readfields(hm, fhm)
char        *hm;
char        *fhm;
{
        int        i;
        int        cnt;
        CLFIELDNODE        **fnode;
        huamian = (CLHMFORM *)malloc(sizeof(CLHMFORM));
        memset(huamian, 0, sizeof(CLHMFORM));
        if((cnt = cl_readhuamian(hm, fhm)) slavelist);
        }
        fnode[cnt] = (CLFIELDNODE *)0;
        
        return(fnode);
}
注意，這里的huamian是一個全局量，定義為CLHMFORM類型指針，此類型在頭文件中定義為：
typedef        struct        _master        {
        char        hmlevel[1];
        char        hmname[20];
        char        hmtype[1];
        CLSLAVE        slavelist[MAX_FIELDS];
}        CLHMFORM;
CLSLAVE的定義是與畫面定義文件中的域的每一行的項目一一對應，含有各域的各種特性。
cl_convdefine()函數(shù)轉換從表單定義文件讀取的域特性信息，他將CLSLAVE類型轉換成可用于域屬性設置及可用于set_field()和new_field()等函數(shù)的類型。CLFIELDNODE結構成員與CLSLAVE的成員一一對應，只不過成員的類型已經從字符數(shù)組變成了可用于建域的各種類型。
CLFIELDNODE *cl_convdefine(slave)
CLSLAVE        slave;
{
        static char        *t = NULL;
        CLFIELDNODE        *data;
        
        data = (CLFIELDNODE *)malloc(sizeof(CLFIELDNODE));
        memset(data, 0, sizeof(CLFIELDNODE));
        t = strstr(slave.length, ".");
        data->pad = atoi(++t);
        t = strtok(slave.length, ".");
        data->length = atoi(t);
        data->id = atoi(slave.seri);
        data->y = atoi(slave.y);
        data->x = atoi(slave.x);
/*
        strncpy(data->name, ut_stripstring(slave.name, " "), 32);
*/
        strncpy(data->name, slave.name, LABEL_MAX_LEN);
        data->buffnum = atoi(slave.bufnum);
        switch(CONV_TYPE(slave.just))        {
                case 'C' :
                        data->just = JUSTIFY_CENTER;
                        break;
                case 'L' :
                        data->just = JUSTIFY_LEFT;
                        break;
                case 'R' :
                        data->just = JUSTIFY_RIGHT;
                        break;
                case 'N' :
                        data->just = NO_JUSTIFICATION;
                        break;
                default :
                        data->just = NO_JUSTIFICATION;
                        break;
        }
        data->ftype = _caseyn(slave.ftype);
        data->selectable = _caseyn(slave.selectable);
        data->inputflag = _caseyn(slave.inputflag);
        data->visible = _caseyn(slave.visible);
        data->passflag = _caseyn(slave.passflag);
        data->enable = _caseyn(slave.enable);
        data->autoskip = 0;
        data->fullflag = _caseyn(slave.fullflag);
        data->pageflag = _caseyn(slave.pageflag);
        data->recvflag = _caseyn(slave.recvflag);
        data->retuflag = _caseyn(slave.retuflag);
        data->retubuff = atoi(slave.retubuf);
        strncpy(data->ddefault, slave.ddefault, LABEL_MAX_LEN);
/*
        strncpy(data->ddefault, ut_stripstring(slave.ddefault, " "), 32);
*/
        switch(CONV_TYPE(slave.dtype))        {
                case 'A' :
                        switch(slave.dtype[1])        {
                                case 'N' :
                                        data->dtype = 0;
                                        break;
                                case 'L' :
                                        data->dtype = 2;
                                        break;
                                case 'M' :
                                        data->dtype = 8;
                                        break;
                                default :
                                        data->dtype = 0;
                                        break;
                        }
                        break;
                case 'E' :
                        data->dtype = 3;
                        break;
                case 'P' :
                        data->dtype = 4;
                        break;
                case 'D' :
                        if(slave.dtype[1] == 'I')
                                data->dtype = 1;
                        else        data->dtype = 5;
                        break;
                case 'R' :
                        data->dtype = 6;
                        break;
                case 'S' :
                        data->dtype = 7;
                        break;
                default :
                        data->dtype = 0;
                        break;
        }
        return(data);
}
cl_readhuamian()函數(shù)打開表單定義文件，用正規(guī)式和fgets()讀取表單主、副畫面號和域定義，他以主、副畫面號為參數(shù)，利用讀取帶分隔符字符串的函數(shù)ut_readtext()將此畫面的域定義讀到全局量huamian。返回此表單畫面的域數(shù)量。
int cl_readhuamian(h, f)
char        *h, *f;
{
        int        p = 0;
        int        cnt = 0;
        int        *t_ps = &cnt;
        static char        hm[80];
        static char        tmpstr[8];
        static char        tstr[200];
        FILE        *pfp;
        if(strcmp(f, " "))        sprintf(hm, FMT2, h, '*', f);
        else        sprintf(hm, "grep \"^%s\\%c\\*\" %s | tail -1", h, '*', EFPATH);
        memset(tstr, 0, 200);
        if(strcmp(f, " "))        sprintf(hm, FMT1, h, f);
        else        sprintf(hm, FMT1, h, "|");
        pfp = popen(hm, "r");
        
        while(fgets(tstr, 180, pfp) != NULL)        {
                p = 0;
        strcpy(tmpstr, ut_readtext(tstr, "|", &p));
        strcpy(tmpstr, ut_readtext(tstr, "|", &p));
        strcpy(huamian->slavelist[*t_ps].seri, ut_readtext(tstr, "|", &p));
        strcpy(huamian->slavelist[*t_ps].name, ut_readtext(tstr, "|", &p));
        strcpy(huamian->slavelist[*t_ps].y, ut_readtext(tstr, "|", &p));
        strcpy(huamian->slavelist[*t_ps].x, ut_readtext(tstr, "|", &p));
        strcpy(huamian->slavelist[*t_ps].length, ut_readtext(tstr, "|", &p));
        strcpy(huamian->slavelist[*t_ps].ftype, ut_readtext(tstr, "|", &p));
        strcpy(huamian->slavelist[*t_ps].bufnum, ut_readtext(tstr, "|", &p));
        strcpy(huamian->slavelist[*t_ps].just, ut_readtext(tstr, "|", &p));
        strcpy(huamian->slavelist[*t_ps].selectable, ut_readtext(tstr, "|", &p));
        strcpy(huamian->slavelist[*t_ps].inputflag, ut_readtext(tstr, "|", &p));
        strcpy(huamian->slavelist[*t_ps].fullflag, ut_readtext(tstr, "|", &p));
        strcpy(huamian->slavelist[*t_ps].enable, ut_readtext(tstr, "|", &p));
        strcpy(huamian->slavelist[*t_ps].visible, ut_readtext(tstr, "|", &p));
        strcpy(huamian->slavelist[*t_ps].passflag, ut_readtext(tstr, "|", &p));
        strcpy(huamian->slavelist[*t_ps].dtype, ut_readtext(tstr, "|", &p));
        strcpy(huamian->slavelist[*t_ps].ddefault, ut_readtext(tstr, "|", &p));
        strcpy(huamian->slavelist[*t_ps].pageflag, ut_readtext(tstr, "|", &p));
        strcpy(huamian->slavelist[*t_ps].recvflag, ut_readtext(tstr, "|", &p));
        strcpy(huamian->slavelist[*t_ps].retuflag, ut_readtext(tstr, "|", &p));
        strcpy(huamian->slavelist[*t_ps].retubuf, ut_readtext(tstr, "|", &p));
                (*t_ps)++;
        }
        pclose(pfp);
        return((*t_ps));
}
讀取了表單畫面文件中的域定義內容之后，就經過轉換就可以利用new_field()建立各域，利用前面講的cl_dispform()和cl_inputdata()就可以顯示表單、進入輸入循環(huán)了。
cl_dispform()調用了cl_createform()。他接收兩個參數(shù)：主畫面號、副畫面號，返回一個FORM結構指針。
FORM *cl_createform(hm, fhm)
char        *hm, *fhm;
{
        
        static        FORM        *form;
        static        int        fldcnt;
        fldcnt = cl_countfldnum(hm, fhm);
        if(fldcnt > 0)        {
                form = new_form(cl_createfields(cl_readfields(hm,fhm), fldcnt));
                return(form);
        }
/*
        if(form)        return(form);
*/
        else        return((FORM *)0);
}
先說明一下cl_countfldnum()，他的主要作用是返回一個整形變量來表示本畫面共有多少個域。借助一個自增的整型指針。
int cl_countfldnum(h, f)
char        *h, *f;
{
        int        cnt = 0;
        int        *t_ps = &cnt;
        static char        hm[80];
        static char        tstr[200];
        FILE        *pfp;
        if(strcmp(f, " "))        sprintf(hm, FMT2, h, '*', f);
        else        sprintf(hm, "grep \"^%s\\%c\\*\" %s | tail -1", h, '*', EFPATH);
        memset(tstr, 0, 200);
        if(strcmp(f, " "))        sprintf(hm, FMT1, h, f);
        else        sprintf(hm, FMT1, h, "|");
        pfp = popen(hm, "r");
        
        while(fgets(tstr, 180, pfp) != NULL)        {
                (*t_ps)++;
        }
        pclose(pfp);
        return((*t_ps));
}
再來說明一下函數(shù)cl_createfields()，他利用CLFIELDNODE指針列表和本畫面域數(shù)量建立各域：確定域類型，是否是標簽，是調用cl_createlabel()否則cl_createfield()。他遍歷CLFIELDNODE指針列表，一個節(jié)點、一個節(jié)點地檢查，分別建立各域，最后返回FIELD指針數(shù)組給cl_createfields()建立表單。
FIELD **cl_createfields(nodelist, fieldcnt)
CLFIELDNODE        **nodelist;
int        fieldcnt;
{
        int        i;
        FIELD        **workfld;
        
        if(fieldcnt ftype)
                        workfld = cl_createfield(nodelist);
                else        workfld = cl_createlabel(nodelist);
        }
        workfld[fieldcnt] = (FIELD *)0;
        return(workfld);
}
FIELD *cl_createfield(no)
CLFIELDNODE        *no;
{
        FIELD        *f;
        if(!no)        return((FIELD *)0);
        f = new_field(1, no->length, no->y, no->x, 0, no->buffnum);
        set_field_userptr(f, (void *)0);
        set_field_just(f, no->just);
        if(no->inputflag)        {
                field_opts_off(f, O_ACTIVE);
        }
        switch(no->dtype)        {
        case        0:
                break;
        case        1:
                set_field_type(f, TYPE_INTEGER, no->pad, -10000000, 10000000);
                break;
        case        2:
                set_field_type(f, TYPE_ALNUM, no->pad);
                break;
        case        3:
                set_field_type(f, TYPE_ENUM, (char **)0, FALSE, FALSE);
                break;
        case        5:
/*
                set_field_type(f, TYPE_REGEXP,
"(19|20)\d\d[- /.](0[[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])");
                set_field_type(f, TYPE_REGEXP,
                "[1-2][0-9][0-9][0-9](0[1-9]\r1[012])[0-3][0-9]");
*/
                set_field_type(f, TYPE_REGEXP,
                "[1-2][0-9][0-9][0-9][0-1][0-9][0-3][0-9]");
                break;
        case        6:
                set_field_type(f, TYPE_REGEXP, "[a-zA-Z,/\\~0-9]");
                break;
        case        7:
                break;
        case        8:
                set_field_type(f, TYPE_NUMERIC, no->pad, -10000000, 10000000);
                break;
        default :
                break;
        }
        
        if(f)        return(f);
        else        return((FIELD *)0);
}
               
FIELD *cl_createlabel(no)
CLFIELDNODE        *no;
{
        FIELD        *f;
        int        len;
        
        if(!no)        return((FIELD *)0);
        if(!no->length)        
                len = strlen(no->name);
        else        len = no->length;
        
        f = new_field(1, len, no->y, no->x, 0, 0);
        
        if(f)        {
                set_field_buffer(f, 0, no->name);
                set_field_just(f, no->just);
                field_opts_off(f, O_ACTIVE);
                return(f);
        }
        else        return((FIELD *)0);
}
cl_createfield()函數(shù)傳遞一個參數(shù):CLFIELDNODE指針no，然后調用new_field()利用CLFIELDNODE的域信息建立新域，調用set_field_userptr()、set_field_just()、set_field_type()等調正域屬性，返回域指針。
而cl_createlable()就比較簡單，他的參數(shù)與返回值與cl_createfield()一樣，他利用域的坐標建立一個域，然后調用
set_field_buffer(f, 0, no->name);
set_field_just(f, no->just);
set_opts_off(f, O_ACTIVE);
來使他顯示標簽名稱，光標不在其上停留。
這幾個函數(shù)之間的關系：
+-----------------------------------------+
|cl_dispform()                            |
|->cl_createform()                        |
|    |->cl_countfldnum()                  |
|       |->cl_createfields()              |
|            |->cl_readfields()           |
|                 |->cl_readhuamian()     |
|                 |->cl_convdefine()      |
|            |->cl_createfield()          |
|            |->cl_createlabel()          |         
|    |->new_field()                       |
+-----------------------------------------+
順便說以下數(shù)據(jù)輸入函數(shù)cl_inputdata()，這個函數(shù)在顯示表單后，等待用戶輸入數(shù)據(jù)，他和cl_dispform()一起構成了用戶的主界面。他的返回值現(xiàn)在有兩個：一個是F4一個是ESC。ESC取消F4提交。他的主要參數(shù)是一個WINDOW指針，以確定表單窗口，一個FORM指針，即用戶表單，由cl_dispform()返回，一個數(shù)據(jù)緩沖區(qū)，保存用戶數(shù)據(jù)，一個32位掩碼，對應32個域，以確定那些域可以返回以填充數(shù)據(jù)緩沖區(qū)。
int cl_inputdata(win, form, imask, idata)
WINDOW        *win;
FORM        *form;
unsigned long        imask;
char        *idata;
{
        
        int        rc;
        int        finish = 0;
        int        fldidx;
        int        fldcnt;
        int        rows, cols, frow, fcol, nrow, nbuf;
        FIELD        **flist = (FIELD **)0;
        fldcnt = field_count(form);
        cl_setcurrent(win);
        cl_outputdata(win, form, imask, idata, 1);
        memset(idata, 0, DATA_DEFAU_LEN);
        while(!finish)        {
                switch(form_driver(form, rc = cl_virtualize(form, workwin)))
                {
                case        E_OK:
                                break;
                case        E_UNKNOWN_COMMAND :
                                switch(cl_getrequest(rc))        {
                                case        9:
                                        finish = 9;
                                        break;
                                case        4:
                                        finish = 4;
                                        form_driver(form, REQ_VALIDATION);
                                        flist = form_fields(form);
for(fldidx = 0; fldidx  0)        {
                        strcat(idata, field_buffer(flist[fldidx], 1));
                        strcat(idata, "|");
                } else {
                        strcat(idata, field_buffer(flist[fldidx], 0));
                        strcat(idata, "|");
                }
        }
}
                                        break;
                                default :
                                        finish = 0;
                                        break;
                                }        /* switch */
                        break;
                default :
/*
------------------------if using this then form input no loop ---------------
                        finish = -1;
*/
                        break;
                }        /* switch */
        }                /* while */
        return(rc);
}
這里的cl_outputdata()用于顯示用戶數(shù)據(jù)緩沖區(qū)的原始內容，ut_getbit()是篩選掩碼用的函數(shù)，看哪位是1，如該位為1，則使用
該位代表的域數(shù)據(jù)。然后看是否是密碼域，是則使用1號域緩沖區(qū)，否則使用默認域緩沖區(qū)。


本文來自ChinaUnix博客，如果查看原文請點：http://blog.chinaunix.net/u/31/showart_508043.html