5　将输入切换到应用程序窗口（harib21e）

虽然我们已经实现了像walk.hrb这样让应用程序接受键盘输入的功能，不过仔细看画面会发现，处于输入状态的其实是命令行窗口，而不是walk的窗口。

5　将输入切换到应用程序窗口（harib21e） - 图1

用harib21d移动“*”时的样子

这样看上去有点怪，应该先让应用程序窗口处于输入状态，然后再操作“*”进行移动。

之前我们所使用的Tab键切换很简单，只能在两个窗口之间交替进行，但这次我们已经显示出了3个以上的窗口，情况变得有点复杂，在按下Tab键时，我们需要判断切换到哪个窗口。我们先这样规定吧：按下Tab键时将键盘输入切换到当前输入窗口下面一层的窗口中，若当前窗口为最下层，则切换到最上层窗口。

■■■■■

对于键盘输入的控制我们之前用的是key_to这个变量，不过这已经是很久以前写的了（应该是在17.3节中写的，也就是差不多一个礼拜之前吧，但感觉好像已经过了很久了呢），这个方法现在已经不能用了，于是我们改成使用key_win这个变量存放当前处于输入模式的窗口地址。

另外，还有一个问题，如果当应用程序窗口处于输入模式时被关闭的话要怎样处理呢？这个时候我们可以让系统自动切换到最上层的窗口。

本次修改的内容较多。主要修改的地方是将HariMain中key_to的地方改为key_win，以及添加在输入窗口消失时（被关闭时）进行处理的代码。

有个细节需要讲一下，我们用SHEET结构中的task成员来判断数据发送对象的FIFO，因此在sht_cons—>task中也加入了TASK结构的地址，这样的话我们就无法分辨窗口是不是由应用程序生成的，于是我们需要通过SHEET结构中的flags成员进行判断（以0x10比特位进行区分）。此外，只有命令行窗口需要控制光标的ON/OFF，应用程序窗口不需要，这一区别也是通过flags来进行判断的（以0x20比特位进行区分）。

本次的bootpack.c节选

  1. void HariMain(void)
  2. {
  3.     （中略）
  4.     struct SHEET *sht = 0, *key_win;    /*这里！*/
  6.     （中略）
  7.     key_win = sht_win;                                  /*从此开始*/
  8.     sht_cons->task = task_cons;
  9.     sht_cons->flags |= 0x20;    /*有光标*/         /*到此结束*/
  11.     （中略）
  13.     for (;;) {
  14.         （中略）
  15.         if (fifo32_status(&fifo) == 0) {
  16.             （中略）
  17.         } else {
  18.             i = fifo32_get(&fifo);
  19.             io_sti();
  20.             if (key_win->flags == 0) {  /*输入窗口被关闭*/               /*从此开始*/
  21.                 key_win = shtctl->sheets[shtctl->top - 1];
  22.                 cursor_c = keywin_on(key_win, sht_win, cursor_c);
  23.             }                                                                   /*到此结束*/
  24.             if (256 <= i && i <= 511) { /*键盘数据*/
  25.                 （中略）
  26.                 if (s[0] != 0) { /*一般字符*/
  27. /*从此开始*/        if (key_win == sht_win) {   /*发送至任务A */
  28.                         if (cursor_x < 128) {
  29.                             /*显示一个字符并将光标后移一位*/
  30.                             s[1] = 0;
  31.                             putfonts8_asc_sht(sht_win, cursor_x, 28, COL8_000000, COL8_FFFFFF, s, 1);
  32.                             cursor_x += 8;
  33.                         }
  34.                     } else {    /*发送至命令行窗口*/
  35.                         fifo32_put(&key_win->task->fifo, s[0] + 256);
  36.                     }
  37.                 }
  38.                 if (i == 256 + 0x0e) {  /*退格键*/
  39.                     if (key_win == sht_win) {   /*发送至任务A */
  40.                         if (cursor_x > 8) {
  41.                             /*用空格擦除光标后将光标前移一位*/
  42.                             putfonts8_asc_sht(sht_win, cursor_x, 28, COL8_000000, COL8_FFFFF ", 1);
  43.                             cursor_x -= 8;
  44.                         }
  45.                     } else {    /*发送至命令行窗口*/
  46.                         fifo32_put(&key_win->task->fifo, 8 + 256);
  47.                     }
  48.                 }
  49.                 if (i == 256 + 0x1c) {  /*回车键*/
  50.                     if (key_win != sht_win) {   /*发送至命令行窗口*/
  51.                         fifo32_put(&key_win->task->fifo, 10 + 256);
  52.                     }
  53.                 }
  54.                 if (i == 256 + 0x0f) {  /* Tab键*/
  56.                     cursor_c = keywin_off(key_win, sht_win, cursor_c, cursor_x);
  57.                     j = key_win->height - 1;
  58.                     if (j == 0) {
  59.                         j = shtctl->top - 1;
  60.                     }
  61.                     key_win = shtctl->sheets[j];
  62. /*到此结束*/        cursor_c = keywin_on(key_win, sht_win, cursor_c);
  63.                 }
  64.                 （中略）
  65.             } else if (512 <= i && i <= 767) { /*鼠标数据*/
  66.                 if (mouse_decode(&mdec, i - 512) != 0) {
  67.                     （中略）
  68.                     if ((mdec.btn & 0x01) != 0) {
  69.                         /*按下左键*/
  70.                         if (mmx < 0) {
  71.                             /*如果处于通常模式*/
  72.                             /*按照从上到下的顺序寻找鼠标所指向的图层*/
  73.                             for (j = shtctl->top - 1; j > 0; j--) {
  74.                                 （中略）
  75.                                 if (0 <= x && x < sht->bxsize && 0 <= y && y < sht->bysize) {
  76.                                     if (sht->buf[y * sht->bxsize + x] != sht->col_inv) {
  77.                                         （中略）
  78.                                         if (sht->bxsize - 21 <= x && x < sht->bxsize - 5 && 5 <=  y && y < 19) {
  79.                                             /*点击“×”按钮*/
  80.             /*这里！*/                      if ((sht->flags & 0x10) != 0) {     /*是由应用程序生成的窗口吗？*/
  81.                                                 （中略）
  82.                                             }
  83.                                         }
  84.                                         break;
  85.                                     }
  86.                                 }
  87.                             }
  88.                         } else {
  89.                             （中略）
  90.                         }
  91.                     } else {
  92.                         （中略）
  93.                     }
  94.                 }
  95.             } else if (i <= 1) { /*光标用定时器*/
  96.                 （中略）
  97.             }
  98.         }
  99.     }
  100. }

上面的代码中调用了keywin_on和keywin_off两个函数，它们的功能是控制窗口标题栏的颜色和task_a窗口的光标，我们将它们写在bootpack.c中。

本次的bootpack.c节选

  1. int keywin_off(struct SHEET *key_win, struct SHEET *sht_win, int cur_c, int cur_x)
  2. {
  3.     change_wtitle8(key_win, 0);
  4.     if (key_win == sht_win) {
  5.         cur_c = -1; /*删除光标*/
  6.         boxfill8(sht_win->buf, sht_win->bxsize, COL8_FFFFFF, cur_x, 28, cur_x + 7, 43);
  7.     } else {
  8.         if ((key_win->flags & 0x20) != 0) {
  9.             fifo32_put(&key_win->task->fifo, 3); /*命令行窗口光标OFF */
  10.         }
  11.     }
  12.     return cur_c;
  13. }
  15. int keywin_on(struct SHEET *key_win, struct SHEET *sht_win, int cur_c)
  16. {
  17.     change_wtitle8(key_win, 1);
  18.     if (key_win == sht_win) {
  19.         cur_c = COL8_000000; /*显示光标*/
  20.     } else {
  21.         if ((key_win->flags & 0x20) != 0) {
  22.             fifo32_put(&key_win->task->fifo, 2); /*命令行窗口光标ON */
  23.         }
  24.     }
  25.     return cur_c;
  26. }

上面的代码中我们调用了一个叫做change_wtitle8的函数，这个函数的功能是改变窗口标题栏的颜色，我们写在window.c中。其实make_wtitle8也可以实现相同的功能，但change_wtitle8的好处是，即便不知道窗口的名称也可以改变标题栏的颜色。除此之外，代码的其余部分应该不需要讲解了吧。

本次的window.c节选

  1. void change_wtitle8(struct SHEET *sht, char act)
  2. {
  3.     int x, y, xsize = sht->bxsize;
  4.     char c, tc_new, tbc_new, tc_old, tbc_old, *buf = sht->buf;
  5.     if (act != 0) {
  6.         tc_new  = COL8_FFFFFF;
  7.         tbc_new = COL8_000084;
  8.         tc_old  = COL8_C6C6C6;
  9.         tbc_old = COL8_848484;
  10.     } else {
  11.         tc_new  = COL8_C6C6C6;
  12.         tbc_new = COL8_848484;
  13.         tc_old  = COL8_FFFFFF;
  14.         tbc_old = COL8_000084;
  15.     }
  16.     for (y = 3; y <= 20; y++) {
  17.         for (x = 3; x <= xsize - 4; x++) {
  18.             c = buf[y * xsize + x];
  19.             if (c == tc_old && x <= xsize - 22) {
  20.                 c = tc_new;
  21.             } else if (c == tbc_old) {
  22.                 c = tbc_new;
  23.             }
  24.             buf[y * xsize + x] = c;
  25.         }
  26.     }
  27.     sheet_refresh(sht, 3, 3, xsize, 21);
  28.     return;
  29. }

我们对cmd_app也进行了修改，主要修改了应用程序结束时自动关闭窗口的部分。因为没有运行应用程序的命令行窗口，其task也不为0，所以需要通过flags的0x10比特位来判断是否自动关闭。

本次的console.c节选

  1. int cmd_app(struct CONSOLE *cons, int *fat, char *cmdline)
  2. {
  3.     （中略）
  4.     if (finfo != 0) {
  5.         （中略）
  6.         if (finfo->size >= 36 && strncmp(p + 4, "Hari", 4) == 0 && *p == 0x00) {
  7.             （中略）
  8.             for (i = 0; i < MAX_SHEETS; i++) {
  9.                 sht = &(shtctl->sheets0[i]);
  10.                 if ((sht->flags & 0x11) == 0x11 && sht->task == task) {     /*这里！*/
  11.                     /*找到应用程序残留的窗口*/
  12.                     sheet_free(sht);    /*关闭*/
  13.                 }
  14.             }
  15.             memman_free_4k(memman, (int) q, segsiz);
  16.         } else {
  17.             cons_putstr0(cons, ".hrb file format error.\n");
  18.         }
  19.         （中略）
  20.     }
  21.     （中略）
  22. }

我们还修改了hrb_api，为了在打开窗口的地方启用自动关闭窗口的功能，我们将flags和0x10进行OR运算。

本次的console.c节选

  1. int *hrb_api(int edi, int esi, int ebp, int esp, int ebx, int edx, int ecx, int eax)
  2. {
  3.     （中略）
  4.     } else if (edx == 5) {
  5.         sht = sheet_alloc(shtctl);
  6.         sht->task = task;
  7.         sht->flags |= 0x10;     /*这里！*/
  8.         sheet_setbuf(sht, (char *) ebx + ds_base, esi, edi, eax);
  9.         make_window8((char *) ebx + ds_base, esi, edi, (char *) ecx + ds_base, 0);
  10.         sheet_slide(sht, 100, 50);
  11.         sheet_updown(sht, 3);   /*图层高度3位于task_a之上*/
  12.         reg[7] = (int) sht;
  13.     } else if (edx == 6) {
  14.     （中略）
  15. }

下面轮到例行的“make run”了。成功了！

5　将输入切换到应用程序窗口（harib21e） - 图2

选择了应用程序窗口