在Sco下利用Curses/Form建立简单的用户界面(三)

unixsystem

在Sco下利用Curses/Form建立简单的用户界面(三)

1. 
   
2. 在使用表单工作时，有时不希望使用new_field()来一个域一个域地建立表单，这样做不仅麻烦也不便与修改，每次画面变更之后还要重新编译。这里我们采用一个更加通用的方法--建立一个表单格式定义文件，使程序代码在每次调用表单时都读取这个文件，搜索指定表单，不用重新编译，就可以马上改变画面。
   
3. 这个表单定义文件的格式是：
   
4. 1001*0*联机签到
   
5. 1001|0|000|柜   员：|12|24||......
   
6. 1001|0|001||12|32|8|......
   
7. 1001|0|002|密   码：|14|24||......
   
8. 1001|0|003||14|32|8|......
   
9. 1002*0*修改柜员密码
   
10. ......
    
11. 每个表单在此文件中有一个唯一的主画面号。比如1001等，几个副画面号如0 1 等，在定义时用*分隔；而表单中的每一个域都在此文件中定义，表单域的各特征项如所属主画面号、副画面号、序号、名称、位置、长度、是否标签域、是否密码域、是否返回、所用缓冲区号、对齐、类型等等都用|分隔。这些时建域时使用的。
    
12. 要利用此文本文件建域，就需要一些工作：
    
13. 首先以画面号、副画面号来读取文件中的域定义：
    
14. 
    
15. CLFIELDNODE **cl_readfields(hm, fhm)
    
16. char        *hm;
    
17. char        *fhm;
    
18. {
    
19. 
    
20.         int        i;
    
21.         int        cnt;
    
22. 
    
23.         CLFIELDNODE        **fnode;
    
24. 
    
25.         huamian = (CLHMFORM *)malloc(sizeof(CLHMFORM));
    
26.         memset(huamian, 0, sizeof(CLHMFORM));
    
27. 
    
28.         if((cnt = cl_readhuamian(hm, fhm)) <= 0)       
    
29.                 return((CLFIELDNODE **)0);
    
30.        
    
31.         fnode = (CLFIELDNODE **)calloc(cnt + 1, sizeof(CLFIELDNODE));
    
32.        
    
33.         for(i = 0; i < cnt; i++)        {
    
34.                 fnode[i] = cl_convdefine(huamian->slavelist[i]);
    
35.         }
    
36. 
    
37.         fnode[cnt] = (CLFIELDNODE *)0;
    
38.        
    
39.         return(fnode);
    
40. 
    
41. }
    
42. 注意，这里的huamian是一个全局量，定义为CLHMFORM类型指针，此类型在头文件中定义为：
    
43. typedef        struct        _master        {
    
44.         char        hmlevel[1];
    
45.         char        hmname[20];
    
46.         char        hmtype[1];
    
47.         CLSLAVE        slavelist[MAX_FIELDS];
    
48. }        CLHMFORM;
    
49. CLSLAVE的定义是与画面定义文件中的域的每一行的项目一一对应，含有各域的各种特性。
    
50. cl_convdefine()函数转换从表单定义文件读取的域特性信息，他将CLSLAVE类型转换成可用于域属性设置及可用于set_field()和new_field()等函数的类型。CLFIELDNODE结构成员与CLSLAVE的成员一一对应，只不过成员的类型已经从字符数组变成了可用于建域的各种类型。
    
51. CLFIELDNODE *cl_convdefine(slave)
    
52. CLSLAVE        slave;
    
53. {
    
54. 
    
55.         static char        *t = NULL;
    
56. 
    
57.         CLFIELDNODE        *data;
    
58.        
    
59.         data = (CLFIELDNODE *)malloc(sizeof(CLFIELDNODE));
    
60.         memset(data, 0, sizeof(CLFIELDNODE));
    
61. 
    
62.         t = strstr(slave.length, ".");
    
63.         data->pad = atoi(++t);
    
64.         t = strtok(slave.length, ".");
    
65.         data->length = atoi(t);
    
66.         data->id = atoi(slave.seri);
    
67.         data->y = atoi(slave.y);
    
68.         data->x = atoi(slave.x);
    
69. 
    
70. /*
    
71.         strncpy(data->name, ut_stripstring(slave.name, " "), 32);
    
72. */
    
73.         strncpy(data->name, slave.name, LABEL_MAX_LEN);
    
74.         data->buffnum = atoi(slave.bufnum);
    
75. 
    
76.         switch(CONV_TYPE(slave.just))        {
    
77.                 case 'C' :
    
78.                         data->just = JUSTIFY_CENTER;
    
79.                         break;
    
80.                 case 'L' :
    
81.                         data->just = JUSTIFY_LEFT;
    
82.                         break;
    
83.                 case 'R' :
    
84.                         data->just = JUSTIFY_RIGHT;
    
85.                         break;
    
86.                 case 'N' :
    
87.                         data->just = NO_JUSTIFICATION;
    
88.                         break;
    
89.                 default :
    
90.                         data->just = NO_JUSTIFICATION;
    
91.                         break;
    
92. 
    
93.         }
    
94. 
    
95.         data->ftype = _caseyn(slave.ftype);
    
96.         data->selectable = _caseyn(slave.selectable);
    
97.         data->inputflag = _caseyn(slave.inputflag);
    
98.         data->visible = _caseyn(slave.visible);
    
99.         data->passflag = _caseyn(slave.passflag);
    
100.         data->enable = _caseyn(slave.enable);
     
101.         data->autoskip = 0;
     
102.         data->fullflag = _caseyn(slave.fullflag);
     
103.         data->pageflag = _caseyn(slave.pageflag);
     
104.         data->recvflag = _caseyn(slave.recvflag);
     
105.         data->retuflag = _caseyn(slave.retuflag);
     
106.         data->retubuff = atoi(slave.retubuf);
     
107. 
     
108.         strncpy(data->ddefault, slave.ddefault, LABEL_MAX_LEN);
     
109. /*
     
110.         strncpy(data->ddefault, ut_stripstring(slave.ddefault, " "), 32);
     
111. */
     
112. 
     
113.         switch(CONV_TYPE(slave.dtype))        {
     
114.                 case 'A' :
     
115.                         switch(slave.dtype[1])        {
     
116.                                 case 'N' :
     
117.                                         data->dtype = 0;
     
118.                                         break;
     
119.                                 case 'L' :
     
120.                                         data->dtype = 2;
     
121.                                         break;
     
122.                                 case 'M' :
     
123.                                         data->dtype = 8;
     
124.                                         break;
     
125.                                 default :
     
126.                                         data->dtype = 0;
     
127.                                         break;
     
128.                         }
     
129.                         break;
     
130. 
     
131.                 case 'E' :
     
132.                         data->dtype = 3;
     
133.                         break;
     
134.                 case 'P' :
     
135.                         data->dtype = 4;
     
136.                         break;
     
137.                 case 'D' :
     
138.                         if(slave.dtype[1] == 'I')
     
139.                                 data->dtype = 1;
     
140.                         else        data->dtype = 5;
     
141.                         break;
     
142.                 case 'R' :
     
143.                         data->dtype = 6;
     
144.                         break;
     
145.                 case 'S' :
     
146.                         data->dtype = 7;
     
147.                         break;
     
148.                 default :
     
149.                         data->dtype = 0;
     
150.                         break;
     
151.         }
     
152. 
     
153.         return(data);
     
154. }
     
155. 
     
156. cl_readhuamian()函数打开表单定义文件，用正规式和fgets()读取表单主、副画面号和域定义，他以主、副画面号为参数，利用读取带分隔符字符串的函数ut_readtext()将此画面的域定义读到全局量huamian。返回此表单画面的域数量。
     
157. int cl_readhuamian(h, f)
     
158. char        *h, *f;
     
159. {
     
160. 
     
161.         int        p = 0;
     
162.         int        cnt = 0;
     
163.         int        *t_ps = &cnt;
     
164. 
     
165.         static char        hm[80];
     
166.         static char        tmpstr[8];
     
167.         static char        tstr[200];
     
168. 
     
169.         FILE        *pfp;
     
170. 
     
171.         if(strcmp(f, " "))        sprintf(hm, FMT2, h, '*', f);
     
172.         else        sprintf(hm, "grep \"^%s\\%c\\*\" %s | tail -1", h, '*', EFPATH);
     
173. 
     
174.         memset(tstr, 0, 200);
     
175.         if(strcmp(f, " "))        sprintf(hm, FMT1, h, f);
     
176.         else        sprintf(hm, FMT1, h, "|");
     
177. 
     
178.         pfp = popen(hm, "r");
     
179.        
     
180. 
     
181.         while(fgets(tstr, 180, pfp) != NULL)        {
     
182.                 p = 0;
     
183.         strcpy(tmpstr, ut_readtext(tstr, "|", &p));
     
184.         strcpy(tmpstr, ut_readtext(tstr, "|", &p));
     
185.         strcpy(huamian->slavelist[*t_ps].seri, ut_readtext(tstr, "|", &p));
     
186.         strcpy(huamian->slavelist[*t_ps].name, ut_readtext(tstr, "|", &p));
     
187.         strcpy(huamian->slavelist[*t_ps].y, ut_readtext(tstr, "|", &p));
     
188.         strcpy(huamian->slavelist[*t_ps].x, ut_readtext(tstr, "|", &p));
     
189.         strcpy(huamian->slavelist[*t_ps].length, ut_readtext(tstr, "|", &p));
     
190.         strcpy(huamian->slavelist[*t_ps].ftype, ut_readtext(tstr, "|", &p));
     
191.         strcpy(huamian->slavelist[*t_ps].bufnum, ut_readtext(tstr, "|", &p));
     
192.         strcpy(huamian->slavelist[*t_ps].just, ut_readtext(tstr, "|", &p));
     
193.         strcpy(huamian->slavelist[*t_ps].selectable, ut_readtext(tstr, "|", &p));
     
194.         strcpy(huamian->slavelist[*t_ps].inputflag, ut_readtext(tstr, "|", &p));
     
195.         strcpy(huamian->slavelist[*t_ps].fullflag, ut_readtext(tstr, "|", &p));
     
196.         strcpy(huamian->slavelist[*t_ps].enable, ut_readtext(tstr, "|", &p));
     
197.         strcpy(huamian->slavelist[*t_ps].visible, ut_readtext(tstr, "|", &p));
     
198.         strcpy(huamian->slavelist[*t_ps].passflag, ut_readtext(tstr, "|", &p));
     
199.         strcpy(huamian->slavelist[*t_ps].dtype, ut_readtext(tstr, "|", &p));
     
200.         strcpy(huamian->slavelist[*t_ps].ddefault, ut_readtext(tstr, "|", &p));
     
201.         strcpy(huamian->slavelist[*t_ps].pageflag, ut_readtext(tstr, "|", &p));
     
202.         strcpy(huamian->slavelist[*t_ps].recvflag, ut_readtext(tstr, "|", &p));
     
203.         strcpy(huamian->slavelist[*t_ps].retuflag, ut_readtext(tstr, "|", &p));
     
204.         strcpy(huamian->slavelist[*t_ps].retubuf, ut_readtext(tstr, "|", &p));
     
205.                 (*t_ps)++;
     
206.         }
     
207.         pclose(pfp);
     
208. 
     
209.         return((*t_ps));
     
210. 
     
211. }
     
212. 
     
213. 读取了表单画面文件中的域定义内容之后，就经过转换就可以利用new_field()建立各域，利用前面讲的cl_dispform()和cl_inputdata()就可以显示表单、进入输入循环了。
     
214. 
     
215. cl_dispform()调用了cl_createform()。他接收两个参数：主画面号、副画面号，返回一个FORM结构指针。
     
216. 
     
217. FORM *cl_createform(hm, fhm)
     
218. char        *hm, *fhm;
     
219. {
     
220.        
     
221.         static        FORM        *form;
     
222.         static        int        fldcnt;
     
223. 
     
224.         fldcnt = cl_countfldnum(hm, fhm);
     
225.         if(fldcnt > 0)        {
     
226.                 form = new_form(cl_createfields(cl_readfields(hm,fhm), fldcnt));
     
227.                 return(form);
     
228.         }
     
229. 
     
230. /*
     
231.         if(form)        return(form);
     
232. */
     
233.         else        return((FORM *)0);
     
234. }
     
235. 
     
236. 先说明一下cl_countfldnum()，他的主要作用是返回一个整形变量来表示本画面共有多少个域。借助一个自增的整型指针。
     
237. int cl_countfldnum(h, f)
     
238. char        *h, *f;
     
239. {
     
240. 
     
241.         int        cnt = 0;
     
242.         int        *t_ps = &cnt;
     
243. 
     
244.         static char        hm[80];
     
245.         static char        tstr[200];
     
246. 
     
247.         FILE        *pfp;
     
248. 
     
249.         if(strcmp(f, " "))        sprintf(hm, FMT2, h, '*', f);
     
250.         else        sprintf(hm, "grep \"^%s\\%c\\*\" %s | tail -1", h, '*', EFPATH);
     
251. 
     
252.         memset(tstr, 0, 200);
     
253.         if(strcmp(f, " "))        sprintf(hm, FMT1, h, f);
     
254.         else        sprintf(hm, FMT1, h, "|");
     
255. 
     
256.         pfp = popen(hm, "r");
     
257.        
     
258. 
     
259.         while(fgets(tstr, 180, pfp) != NULL)        {
     
260.                 (*t_ps)++;
     
261.         }
     
262.         pclose(pfp);
     
263. 
     
264.         return((*t_ps));
     
265. 
     
266. }
     
267. 
     
268. 再来说明一下函数cl_createfields()，他利用CLFIELDNODE指针列表和本画面域数量建立各域：确定域类型，是否是标签，是调用cl_createlabel()否则cl_createfield()。他遍历CLFIELDNODE指针列表，一个节点、一个节点地检查，分别建立各域，最后返回FIELD指针数组给cl_createfields()建立表单。
     
269. FIELD **cl_createfields(nodelist, fieldcnt)
     
270. CLFIELDNODE        **nodelist;
     
271. int        fieldcnt;
     
272. {
     
273. 
     
274.         int        i;
     
275. 
     
276.         FIELD        **workfld;
     
277.        
     
278. 
     
279.         if(fieldcnt <= 0)        return((FIELD **)0);
     
280. 
     
281.         workfld = (FIELD **)calloc(fieldcnt + 1, sizeof(FIELD));
     
282. 
     
283.         for(i = 0; i < fieldcnt; i++)        {
     
284.                 if(nodelist[i]->ftype)
     
285.                         workfld[i] = cl_createfield(nodelist[i]);
     
286.                 else        workfld[i] = cl_createlabel(nodelist[i]);
     
287.         }
     
288. 
     
289.         workfld[fieldcnt] = (FIELD *)0;
     
290.         return(workfld);
     
291. }
     
292. 
     
293. FIELD *cl_createfield(no)
     
294. CLFIELDNODE        *no;
     
295. {
     
296. 
     
297.         FIELD        *f;
     
298.         if(!no)        return((FIELD *)0);
     
299. 
     
300.         f = new_field(1, no->length, no->y, no->x, 0, no->buffnum);
     
301.         set_field_userptr(f, (void *)0);
     
302.         set_field_just(f, no->just);
     
303.         if(no->inputflag)        {
     
304.                 field_opts_off(f, O_ACTIVE);
     
305.         }
     
306.         switch(no->dtype)        {
     
307.         case        0:
     
308.                 break;
     
309.         case        1:
     
310.                 set_field_type(f, TYPE_INTEGER, no->pad, -10000000, 10000000);
     
311.                 break;
     
312.         case        2:
     
313.                 set_field_type(f, TYPE_ALNUM, no->pad);
     
314.                 break;
     
315.         case        3:
     
316.                 set_field_type(f, TYPE_ENUM, (char **)0, FALSE, FALSE);
     
317.                 break;
     
318.         case        5:
     
319. /*
     
320.                 set_field_type(f, TYPE_REGEXP,
     
321. "(19|20)\d\d[- /.](0[[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])");
     
322.                 set_field_type(f, TYPE_REGEXP,
     
323.                 "[1-2][0-9][0-9][0-9](0[1-9]\r1[012])[0-3][0-9]");
     
324. */
     
325.                 set_field_type(f, TYPE_REGEXP,
     
326.                 "[1-2][0-9][0-9][0-9][0-1][0-9][0-3][0-9]");
     
327.                 break;
     
328.         case        6:
     
329.                 set_field_type(f, TYPE_REGEXP, "[a-zA-Z,<>/\\~0-9]");
     
330.                 break;
     
331.         case        7:
     
332.                 break;
     
333.         case        8:
     
334.                 set_field_type(f, TYPE_NUMERIC, no->pad, -10000000, 10000000);
     
335.                 break;
     
336.         default :
     
337.                 break;
     
338.         }
     
339.        
     
340.         if(f)        return(f);
     
341.         else        return((FIELD *)0);
     
342. }
     
343.                
     
344. FIELD *cl_createlabel(no)
     
345. CLFIELDNODE        *no;
     
346. {
     
347.         FIELD        *f;
     
348. 
     
349.         int        len;
     
350.        
     
351.         if(!no)        return((FIELD *)0);
     
352. 
     
353.         if(!no->length)       
     
354.                 len = strlen(no->name);
     
355.         else        len = no->length;
     
356.        
     
357.         f = new_field(1, len, no->y, no->x, 0, 0);
     
358.        
     
359.         if(f)        {
     
360.                 set_field_buffer(f, 0, no->name);
     
361.                 set_field_just(f, no->just);
     
362.                 field_opts_off(f, O_ACTIVE);
     
363.                 return(f);
     
364.         }
     
365.         else        return((FIELD *)0);
     
366. }
     
367. 
     
368. cl_createfield()函数传递一个参数:CLFIELDNODE指针no，然后调用new_field()利用CLFIELDNODE的域信息建立新域，调用set_field_userptr()、set_field_just()、set_field_type()等调正域属性，返回域指针。
     
369. 而cl_createlable()就比较简单，他的参数与返回值与cl_createfield()一样，他利用域的坐标建立一个域，然后调用
     
370. set_field_buffer(f, 0, no->name);
     
371. set_field_just(f, no->just);
     
372. set_opts_off(f, O_ACTIVE);
     
373. 来使他显示标签名称，光标不在其上停留。
     
374. 
     
375. 这几个函数之间的关系：
     
376. 
     
377. +-----------------------------------------+
     
378. |cl_dispform()                            |
     
379. |->cl_createform()                        |
     
380. |    |->cl_countfldnum()                  |
     
381. |       |->cl_createfields()              |
     
382. |            |->cl_readfields()           |
     
383. |                 |->cl_readhuamian()     |
     
384. |                 |->cl_convdefine()      |
     
385. |            |->cl_createfield()          |
     
386. |            |->cl_createlabel()          |         
     
387. |    |->new_field()                       |
     
388. +-----------------------------------------+
     
389. 
     
390. 顺便说以下数据输入函数cl_inputdata()，这个函数在显示表单后，等待用户输入数据，他和cl_dispform()一起构成了用户的主界面。他的返回值现在有两个：一个是F4一个是ESC。ESC取消F4提交。他的主要参数是一个WINDOW指针，以确定表单窗口，一个FORM指针，即用户表单，由cl_dispform()返回，一个数据缓冲区，保存用户数据，一个32位掩码，对应32个域，以确定那些域可以返回以填充数据缓冲区。
     
391. int cl_inputdata(win, form, imask, idata)
     
392. WINDOW        *win;
     
393. FORM        *form;
     
394. unsigned long        imask;
     
395. char        *idata;
     
396. {
     
397.        
     
398.         int        rc;
     
399.         int        finish = 0;
     
400.         int        fldidx;
     
401.         int        fldcnt;
     
402.         int        rows, cols, frow, fcol, nrow, nbuf;
     
403. 
     
404.         FIELD        **flist = (FIELD **)0;
     
405. 
     
406.         fldcnt = field_count(form);
     
407.         cl_setcurrent(win);
     
408. 
     
409.         cl_outputdata(win, form, imask, idata, 1);
     
410.         memset(idata, 0, DATA_DEFAU_LEN);
     
411. 
     
412.         while(!finish)        {
     
413.                 switch(form_driver(form, rc = cl_virtualize(form, workwin)))
     
414.                 {
     
415.                 case        E_OK:
     
416.                                 break;
     
417.                 case        E_UNKNOWN_COMMAND :
     
418.                                 switch(cl_getrequest(rc))        {
     
419.                                 case        9:
     
420.                                         finish = 9;
     
421.                                         break;
     
422.                                 case        4:
     
423.                                         finish = 4;
     
424.                                         form_driver(form, REQ_VALIDATION);
     
425.                                         flist = form_fields(form);
     
426. for(fldidx = 0; fldidx < fldcnt; fldidx++)        {
     
427.         if(ut_getbits(imask, fldidx))        {
     
428.                 if(field_info(flist[fldidx], &rows, &cols,
     
429.                 &frow, &fcol, &nrow, &nbuf) == E_OK && nbuf > 0)        {
     
430.                         strcat(idata, field_buffer(flist[fldidx], 1));
     
431.                         strcat(idata, "|");
     
432.                 } else {
     
433.                         strcat(idata, field_buffer(flist[fldidx], 0));
     
434.                         strcat(idata, "|");
     
435.                 }
     
436.         }
     
437. }
     
438.                                         break;
     
439.                                 default :
     
440.                                         finish = 0;
     
441.                                         break;
     
442.                                 }        /* switch */
     
443.                         break;
     
444.                 default :
     
445. /*
     
446. ------------------------if using this then form input no loop ---------------
     
447.                         finish = -1;
     
448. */
     
449.                         break;
     
450.                 }        /* switch */
     
451.         }                /* while */
     
452.         return(rc);
     
453. }
     
454. 这里的cl_outputdata()用于显示用户数据缓冲区的原始内容，ut_getbit()是筛选掩码用的函数，看哪位是1，如该位为1，则使用
     
455. 该位代表的域数据。然后看是否是密码域，是则使用1号域缓冲区，否则使用默认域缓冲区。
     
456. 
     
457. （结束，源码以后再传）

复制代码

第一部分.
第二部分.

[ 本帖最后由 unixsystem 于 2007-1-27 00:33 编辑 ]

fans1

正好找这方面的资料，万分感谢阿

abist

高手！！！！！

johnsilver

严重支持!

水水晶晶

想请教一下如何获取form中输入字符串的长度

feelingtel

我有现成开发好的一个平台, 通过配置可以自动生成源代码, 并且完成了和数据库的访问,有人要吗?
联系QQ:79124027

saintdragon

不搞开发，看到这么多代码就眼晕，呵呵