void
console_task(layer_t* layer, unsigned int memtotal)
{
#define INPUT_BEG_POS_X (16)
#define INPUT_BEG_POS_Y (28)
timer_t* timer;
task_t* task = task_now();
mem_mgr_t* memmgr = (mem_mgr_t*)MEMMGR_ADDR;
int data, fifobuf[128];
int* fat = (int*)mem_mgr_alloc_4k(memmgr, 4 * 2880);
char cmdline[32];
console_t console;
console.layer = layer;
console.cur_x = 8;
console.cur_y = INPUT_BEG_POS_Y;
console.cur_c = -1;
*((int*)0x0fec) = (int)&console;
fifo_init(&task->fifo, fifobuf, 128, task);
timer = timer_alloc();
timer_init(timer, &task->fifo, 1);
timer_settimer(timer, 50);
file_readfat(fat, (unsigned char*)(ADR_DISKIMG + 0x000200));
/* display the prompt of console window */
console_putchar(&console, '>', 1);
for ( ; ; ) {
io_cli();
if (0 == fifo_size(&task->fifo)) {
task_sleep(task);
io_sti();
}
else {
data = fifo_get(&task->fifo);
io_sti();
if (data <= 1) {
/* timer for cursor */
if (0 != data) {
timer_init(timer, &task->fifo, 0);
if (console.cur_c >= 0)
console.cur_c = COLOR8_FFFFFF;
}
else {
timer_init(timer, &task->fifo, 1);
if (console.cur_c >= 0)
console.cur_c = COLOR8_000000;
}
timer_settimer(timer, 50);
}
if (2 == data) /* cursor ON */
console.cur_c = COLOR8_FFFFFF;
if (3 == data) { /* cursor OFF */
fill_box8(layer->buf, layer->w_size,
COLOR8_000000, console.cur_x, console.cur_y,
console.cur_x + 7, console.cur_y + 15);
console.cur_c = -1;
}
if (256 <= data && data <= 511) {
/* keyboard data */
if ((8 + 256) == data) {
/* backspace */
if (console.cur_x > INPUT_BEG_POS_X) {
/* erase the cursor and move forward one character */
console_putchar(&console, ' ', 0);
console.cur_x -= 8;
}
}
else if ((10 + 256) == data) {
/* Enter Key */
/* erase cursor by space */
console_putchar(&console, ' ', 0);
cmdline[console.cur_x / 8 - 2] = 0;
console_newline(&console);
console_runcmd(&console, cmdline, fat, memtotal);
/* show the prompt */
console_putchar(&console, '>', 1);
}
else {
/* general character */
if (console.cur_x < 240) {
/* display one character and move backward one character */
cmdline[console.cur_x / 8 - 2] = data - 256;
console_putchar(&console, data - 256, 1);
}
}
}
/* show the cursor again */
if (console.cur_c >= 0) {
fill_box8(layer->buf, layer->w_size,
console.cur_c, console.cur_x, console.cur_y,
console.cur_x + 7, console.cur_y + 15);
}
layers_refresh(layer, console.cur_x, console.cur_y,
console.cur_x + 8, console.cur_y + 16);
}
}
}
void console_task(struct SHEET *sheet, unsigned int memtotal)
{
struct TIMER *timer;
struct TASK *task = task_now();
struct MEMMAN *memman = (struct MEMMAN *) MEMMAN_ADDR;
int i, fifobuf[128], *fat = (int *) memman_alloc_4k(memman, 4 * 2880);
struct CONSOLE cons;
char cmdline[30];
cons.sht = sheet;
cons.cur_x = 8;
cons.cur_y = 28;
cons.cur_c = -1;
*((int *) 0x0fec) = (int) &cons;
fifo32_init(&task->fifo, 128, fifobuf, task);
timer = timer_alloc();
timer_init(timer, &task->fifo, 1);
timer_settime(timer, 50);
file_readfat(fat, (unsigned char *) (ADR_DISKIMG + 0x000200));
/* プロンプト表示 */
cons_putchar(&cons, '>', 1);
for (;;) {
io_cli();
if (fifo32_status(&task->fifo) == 0) {
task_sleep(task);
io_sti();
} else {
i = fifo32_get(&task->fifo);
io_sti();
if (i <= 1) { /* カーソル用タイマ */
if (i != 0) {
timer_init(timer, &task->fifo, 0); /* 次は0を */
if (cons.cur_c >= 0) {
cons.cur_c = COL8_FFFFFF;
}
} else {
timer_init(timer, &task->fifo, 1); /* 次は1を */
if (cons.cur_c >= 0) {
cons.cur_c = COL8_000000;
}
}
timer_settime(timer, 50);
}
if (i == 2) { /* カーソルON */
cons.cur_c = COL8_FFFFFF;
}
if (i == 3) { /* カーソルOFF */
boxfill8(sheet->buf, sheet->bxsize, COL8_000000, cons.cur_x, cons.cur_y, cons.cur_x + 7, cons.cur_y + 15);
cons.cur_c = -1;
}
if (256 <= i && i <= 511) { /* キーボードデータ（タスクA経由） */
if (i == 8 + 256) {
/* バックスペース */
if (cons.cur_x > 16) {
/* カーソルをスペースで消してから、カーソルを1つ戻す */
cons_putchar(&cons, ' ', 0);
cons.cur_x -= 8;
}
} else if (i == 10 + 256) {
/* Enter */
/* カーソルをスペースで消してから改行する */
cons_putchar(&cons, ' ', 0);
cmdline[cons.cur_x / 8 - 2] = 0;
cons_newline(&cons);
cons_runcmd(cmdline, &cons, fat, memtotal); /* コマンド実行 */
/* プロンプト表示 */
cons_putchar(&cons, '>', 1);
} else {
/* 一般文字 */
if (cons.cur_x < 240) {
/* 一文字表示してから、カーソルを1つ進める */
cmdline[cons.cur_x / 8 - 2] = i - 256;
cons_putchar(&cons, i - 256, 1);
}
}
}
/* カーソル再表示 */
if (cons.cur_c >= 0) {
boxfill8(sheet->buf, sheet->bxsize, cons.cur_c, cons.cur_x, cons.cur_y, cons.cur_x + 7, cons.cur_y + 15);
}
sheet_refresh(sheet, cons.cur_x, cons.cur_y, cons.cur_x + 8, cons.cur_y + 16);
}
}
}
void console_task(struct SHEET *sheet, unsigned int memtotal)
{
struct TIMER *timer;
struct TASK *task = task_now();
int i, fifobuf[128], cursor_x = 16, cursor_y = 28, cursor_c = -1;
char s[30], cmdline[30], *p;
struct MEMMAN *memman = (struct MEMMAN *) MEMMAN_ADDR;
int x, y;
struct FILEINFO *finfo = (struct FILEINFO *) (ADR_DISKIMG + 0x002600);
int *fat = (int *) memman_alloc_4k(memman, 4 * 2880);
struct SEGMENT_DESCRIPTOR *gdt = (struct SEGMENT_DESCRIPTOR *) ADR_GDT;
fifo32_init(&task->fifo, 128, fifobuf, task);
timer = timer_alloc();
timer_init(timer, &task->fifo, 1);
timer_settime(timer, 50);
file_readfat(fat, (unsigned char *) (ADR_DISKIMG + 0x000200));
putfonts8_asc_sht(sheet, 8, 28, COL8_FFFFFF, COL8_000000, ">", 1);
for (;;) {
io_cli();
if (fifo32_status(&task->fifo) == 0) {
task_sleep(task);
io_sti();
} else {
i = fifo32_get(&task->fifo);
io_sti();
if (i <= 1) {
if (i != 0) {
timer_init(timer, &task->fifo, 0);
if (cursor_c >= 0) {
cursor_c = COL8_FFFFFF;
}
} else {
timer_init(timer, &task->fifo, 1);
if (cursor_c >= 0) {
cursor_c = COL8_000000;
}
}
timer_settime(timer, 50);
}
if (i == 2) {
cursor_c = COL8_FFFFFF;
}
if (i == 3) {
boxfill8(sheet->buf, sheet->bxsize, COL8_000000, cursor_x, cursor_y, cursor_x + 7, cursor_y + 15);
cursor_c = -1;
}
if (256 <= i && i <= 511) {
if (i == 8 + 256) {
if (cursor_x > 16) {
putfonts8_asc_sht(sheet, cursor_x, cursor_y, COL8_FFFFFF, COL8_000000, " ", 1);
cursor_x -= 8;
}
} else if (i == 10 + 256) {
putfonts8_asc_sht(sheet, cursor_x, cursor_y, COL8_FFFFFF, COL8_000000, " ", 1);
cmdline[cursor_x / 8 - 2] = 0;
cursor_y = cons_newline(cursor_y, sheet);
if (strcmp(cmdline, "mem") == 0) {
sprintf(s, "total %dMB", memtotal / (1024 * 1024));
putfonts8_asc_sht(sheet, 8, cursor_y, COL8_FFFFFF, COL8_000000, s, 30);
cursor_y = cons_newline(cursor_y, sheet);
sprintf(s, "free %dKB", memman_total(memman) / 1024);
putfonts8_asc_sht(sheet, 8, cursor_y, COL8_FFFFFF, COL8_000000, s, 30);
cursor_y = cons_newline(cursor_y, sheet);
cursor_y = cons_newline(cursor_y, sheet);
} else if (strcmp(cmdline, "cls") == 0) {
for (y = 28; y < 28 + 128; y++) {
for (x = 8; x < 8 + 240; x++) {
sheet->buf[x + y * sheet->bxsize] = COL8_000000;
}
}
sheet_refresh(sheet, 8, 28, 8 + 240, 28 + 128);
cursor_y = 28;
} else if (strcmp(cmdline, "dir") == 0) {
for (x = 0; x < 224; x++) {
if (finfo[x].name[0] == 0x00) {
break;
}
if (finfo[x].name[0] != 0xe5) {
if ((finfo[x].type & 0x18) == 0) {
sprintf(s, "filename.ext %7d", finfo[x].size);
for (y = 0; y < 8; y++) {
s[y] = finfo[x].name[y];
}
s[ 9] = finfo[x].ext[0];
s[10] = finfo[x].ext[1];
s[11] = finfo[x].ext[2];
putfonts8_asc_sht(sheet, 8, cursor_y, COL8_FFFFFF, COL8_000000, s, 30);
cursor_y = cons_newline(cursor_y, sheet);
}
}
}
cursor_y = cons_newline(cursor_y, sheet);
} else if (strncmp(cmdline, "type ", 5) == 0) {
for (y = 0; y < 11; y++) {
s[y] = ' ';
}
y = 0;
for (x = 5; y < 11 && cmdline[x] != 0; x++) {
if (cmdline[x] == '.' && y <= 8) {
y = 8;
} else {
s[y] = cmdline[x];
if ('a' <= s[y] && s[y] <= 'z') {
s[y] -= 0x20;
}
y++;
}
}
for (x = 0; x < 224; ) {
if (finfo[x].name[0] == 0x00) {
break;
}
if ((finfo[x].type & 0x18) == 0) {
for (y = 0; y < 11; y++) {
if (finfo[x].name[y] != s[y]) {
goto type_next_file;
}
}
break;
}
type_next_file:
x++;
}
if (x < 224 && finfo[x].name[0] != 0x00) {
p = (char *) memman_alloc_4k(memman, finfo[x].size);
file_loadfile(finfo[x].clustno, finfo[x].size, p, fat, (char *) (ADR_DISKIMG + 0x003e00));
cursor_x = 8;
for (y = 0; y < finfo[x].size; y++) {
s[0] = p[y];
s[1] = 0;
if (s[0] == 0x09) {
for (;;) {
putfonts8_asc_sht(sheet, cursor_x, cursor_y, COL8_FFFFFF, COL8_000000, " ", 1);
cursor_x += 8;
if (cursor_x == 8 + 240) {
cursor_x = 8;
cursor_y = cons_newline(cursor_y, sheet);
}
if (((cursor_x - 8) & 0x1f) == 0) {
break;
}
}
} else if (s[0] == 0x0a) {
cursor_x = 8;
cursor_y = cons_newline(cursor_y, sheet);
} else if (s[0] == 0x0d) {
} else {
putfonts8_asc_sht(sheet, cursor_x, cursor_y, COL8_FFFFFF, COL8_000000, s, 1);
cursor_x += 8;
if (cursor_x == 8 + 240) {
cursor_x = 8;
cursor_y = cons_newline(cursor_y, sheet);
}
}
}
memman_free_4k(memman, (int) p, finfo[x].size);
} else {
putfonts8_asc_sht(sheet, 8, cursor_y, COL8_FFFFFF, COL8_000000, "File not found.", 15);
cursor_y = cons_newline(cursor_y, sheet);
}
cursor_y = cons_newline(cursor_y, sheet);
} else if (strcmp(cmdline, "hlt") == 0) {
for (y = 0; y < 11; y++) {
s[y] = ' ';
}
s[0] = 'H';
s[1] = 'L';
s[2] = 'T';
s[8] = 'H';
s[9] = 'R';
s[10] = 'B';
for (x = 0; x < 224; ) {
if (finfo[x].name[0] == 0x00) {
break;
}
if ((finfo[x].type & 0x18) == 0) {
for (y = 0; y < 11; y++) {
if (finfo[x].name[y] != s[y]) {
goto hlt_next_file;
}
}
break;
}
hlt_next_file:
x++;
}
if (x < 224 && finfo[x].name[0] != 0x00) {
p = (char *) memman_alloc_4k(memman, finfo[x].size);
file_loadfile(finfo[x].clustno, finfo[x].size, p, fat, (char *) (ADR_DISKIMG + 0x003e00));
set_segmdesc(gdt + 1003, finfo[x].size - 1, (int) p, AR_CODE32_ER);
farjmp(0, 1003 * 8);
memman_free_4k(memman, (int) p, finfo[x].size);
} else {
putfonts8_asc_sht(sheet, 8, cursor_y, COL8_FFFFFF, COL8_000000, "File not found.", 15);
cursor_y = cons_newline(cursor_y, sheet);
}
cursor_y = cons_newline(cursor_y, sheet);
} else if (cmdline[0] != 0) {
putfonts8_asc_sht(sheet, 8, cursor_y, COL8_FFFFFF, COL8_000000, "Bad command.", 12);
cursor_y = cons_newline(cursor_y, sheet);
cursor_y = cons_newline(cursor_y, sheet);
}
putfonts8_asc_sht(sheet, 8, cursor_y, COL8_FFFFFF, COL8_000000, ">", 1);
cursor_x = 16;
} else {
if (cursor_x < 240) {
s[0] = i - 256;
s[1] = 0;
cmdline[cursor_x / 8 - 2] = i - 256;
putfonts8_asc_sht(sheet, cursor_x, cursor_y, COL8_FFFFFF, COL8_000000, s, 1);
cursor_x += 8;
}
}
}
if (cursor_c >= 0) {
boxfill8(sheet->buf, sheet->bxsize, cursor_c, cursor_x, cursor_y, cursor_x + 7, cursor_y + 15);
}
sheet_refresh(sheet, cursor_x, cursor_y, cursor_x + 8, cursor_y + 16);
}
}
}
void console_task(struct SHEET *sheet, unsigned int memtotal)
{
struct TIMER *timer;
struct TASK *task = task_now();
int i, fifobuf[128], cursor_x = 16, cursor_y = 28, cursor_c = -1;
char s[30], cmdline[30], *p;
struct MEMMAN *memman = (struct MEMMAN *) MEMMAN_ADDR;
int x, y;
struct FILEINFO *finfo = (struct FILEINFO *) (ADR_DISKIMG + 0x002600);
int *fat = (int *) memman_alloc_4k(memman, 4 * 2880);
struct SEGMENT_DESCRIPTOR *gdt = (struct SEGMENT_DESCRIPTOR *) ADR_GDT;
fifo32_init(&task->fifo, 128, fifobuf, task);
timer = timer_alloc();
timer_init(timer, &task->fifo, 1);
timer_settime(timer, 50);
file_readfat(fat, (unsigned char *) (ADR_DISKIMG + 0x000200));
/* プロンプト表示 */
putfonts8_asc_sht(sheet, 8, 28, COL8_FFFFFF, COL8_000000, ">", 1);
for (;;) {
io_cli();
if (fifo32_status(&task->fifo) == 0) {
task_sleep(task);
io_sti();
} else {
i = fifo32_get(&task->fifo);
io_sti();
if (i <= 1) { /* カーソル用タイマ */
if (i != 0) {
timer_init(timer, &task->fifo, 0); /* 次は0を */
if (cursor_c >= 0) {
cursor_c = COL8_FFFFFF;
}
} else {
timer_init(timer, &task->fifo, 1); /* 次は1を */
if (cursor_c >= 0) {
cursor_c = COL8_000000;
}
}
timer_settime(timer, 50);
}
if (i == 2) { /* カーソルON */
cursor_c = COL8_FFFFFF;
}
if (i == 3) { /* カーソルOFF */
boxfill8(sheet->buf, sheet->bxsize, COL8_000000, cursor_x, cursor_y, cursor_x + 7, cursor_y + 15);
cursor_c = -1;
}
if (256 <= i && i <= 511) { /* キーボードデータ（タスクA経由） */
if (i == 8 + 256) {
/* バックスペース */
if (cursor_x > 16) {
/* カーソルをスペースで消してから、カーソルを1つ戻す */
putfonts8_asc_sht(sheet, cursor_x, cursor_y, COL8_FFFFFF, COL8_000000, " ", 1);
cursor_x -= 8;
}
} else if (i == 10 + 256) {
/* Enter */
/* カーソルをスペースで消してから改行する */
putfonts8_asc_sht(sheet, cursor_x, cursor_y, COL8_FFFFFF, COL8_000000, " ", 1);
cmdline[cursor_x / 8 - 2] = 0;
cursor_y = cons_newline(cursor_y, sheet);
/* コマンド実行 */
if (strcmp(cmdline, "mem") == 0) {
/* memコマンド */
sprintf(s, "total %dMB", memtotal / (1024 * 1024));
putfonts8_asc_sht(sheet, 8, cursor_y, COL8_FFFFFF, COL8_000000, s, 30);
cursor_y = cons_newline(cursor_y, sheet);
sprintf(s, "free %dKB", memman_total(memman) / 1024);
putfonts8_asc_sht(sheet, 8, cursor_y, COL8_FFFFFF, COL8_000000, s, 30);
cursor_y = cons_newline(cursor_y, sheet);
cursor_y = cons_newline(cursor_y, sheet);
} else if (strcmp(cmdline, "cls") == 0) {
/* clsコマンド */
for (y = 28; y < 28 + 128; y++) {
for (x = 8; x < 8 + 240; x++) {
sheet->buf[x + y * sheet->bxsize] = COL8_000000;
}
}
sheet_refresh(sheet, 8, 28, 8 + 240, 28 + 128);
cursor_y = 28;
} else if (strcmp(cmdline, "dir") == 0) {
/* dirコマンド */
for (x = 0; x < 224; x++) {
if (finfo[x].name[0] == 0x00) {
break;
}
if (finfo[x].name[0] != 0xe5) {
if ((finfo[x].type & 0x18) == 0) {
sprintf(s, "filename.ext %7d", finfo[x].size);
for (y = 0; y < 8; y++) {
s[y] = finfo[x].name[y];
}
s[ 9] = finfo[x].ext[0];
s[10] = finfo[x].ext[1];
s[11] = finfo[x].ext[2];
putfonts8_asc_sht(sheet, 8, cursor_y, COL8_FFFFFF, COL8_000000, s, 30);
cursor_y = cons_newline(cursor_y, sheet);
}
}
}
cursor_y = cons_newline(cursor_y, sheet);
} else if (strncmp(cmdline, "type ", 5) == 0) {
/* typeコマンド */
/* ファイル名を準備する */
for (y = 0; y < 11; y++) {
s[y] = ' ';
}
y = 0;
for (x = 5; y < 11 && cmdline[x] != 0; x++) {
if (cmdline[x] == '.' && y <= 8) {
y = 8;
} else {
s[y] = cmdline[x];
if ('a' <= s[y] && s[y] <= 'z') {
/* 小文字は大文字に直す */
s[y] -= 0x20;
}
y++;
}
}
/* ファイルを探す */
for (x = 0; x < 224; ) {
if (finfo[x].name[0] == 0x00) {
break;
}
if ((finfo[x].type & 0x18) == 0) {
for (y = 0; y < 11; y++) {
if (finfo[x].name[y] != s[y]) {
goto type_next_file;
}
}
break; /* ファイルが見つかった */
}
type_next_file:
x++;
}
if (x < 224 && finfo[x].name[0] != 0x00) {
/* ファイルが見つかった場合 */
p = (char *) memman_alloc_4k(memman, finfo[x].size);
file_loadfile(finfo[x].clustno, finfo[x].size, p, fat, (char *) (ADR_DISKIMG + 0x003e00));
cursor_x = 8;
for (y = 0; y < finfo[x].size; y++) {
/* 1文字ずつ出力 */
s[0] = p[y];
s[1] = 0;
if (s[0] == 0x09) { /* タブ */
for (;;) {
putfonts8_asc_sht(sheet, cursor_x, cursor_y, COL8_FFFFFF, COL8_000000, " ", 1);
cursor_x += 8;
if (cursor_x == 8 + 240) {
cursor_x = 8;
cursor_y = cons_newline(cursor_y, sheet);
}
if (((cursor_x - 8) & 0x1f) == 0) {
break; /* 4で割り切れたらbreak */
}
}
} else if (s[0] == 0x0a) { /* 改行 */
cursor_x = 8;
cursor_y = cons_newline(cursor_y, sheet);
} else if (s[0] == 0x0d) { /* 復帰 */
/* とりあえずなにもしない */
} else { /* 普通の文字 */
putfonts8_asc_sht(sheet, cursor_x, cursor_y, COL8_FFFFFF, COL8_000000, s, 1);
cursor_x += 8;
if (cursor_x == 8 + 240) {
cursor_x = 8;
cursor_y = cons_newline(cursor_y, sheet);
}
}
}
memman_free_4k(memman, (int) p, finfo[x].size);
} else {
/* ファイルが見つからなかった場合 */
putfonts8_asc_sht(sheet, 8, cursor_y, COL8_FFFFFF, COL8_000000, "File not found.", 15);
cursor_y = cons_newline(cursor_y, sheet);
}
cursor_y = cons_newline(cursor_y, sheet);
} else if (strcmp(cmdline, "hlt") == 0) {
/* hlt.hrbアプリケーションを起動 */
for (y = 0; y < 11; y++) {
s[y] = ' ';
}
s[0] = 'H';
s[1] = 'L';
s[2] = 'T';
s[8] = 'H';
s[9] = 'R';
s[10] = 'B';
for (x = 0; x < 224; ) {
if (finfo[x].name[0] == 0x00) {
break;
}
if ((finfo[x].type & 0x18) == 0) {
for (y = 0; y < 11; y++) {
if (finfo[x].name[y] != s[y]) {
goto hlt_next_file;
}
}
break; /* ファイルが見つかった */
}
hlt_next_file:
x++;
}
if (x < 224 && finfo[x].name[0] != 0x00) {
/* ファイルが見つかった場合 */
p = (char *) memman_alloc_4k(memman, finfo[x].size);
file_loadfile(finfo[x].clustno, finfo[x].size, p, fat, (char *) (ADR_DISKIMG + 0x003e00));
set_segmdesc(gdt + 1003, finfo[x].size - 1, (int) p, AR_CODE32_ER);
farjmp(0, 1003 * 8);
memman_free_4k(memman, (int) p, finfo[x].size);
} else {
/* ファイルが見つからなかった場合 */
putfonts8_asc_sht(sheet, 8, cursor_y, COL8_FFFFFF, COL8_000000, "File not found.", 15);
cursor_y = cons_newline(cursor_y, sheet);
}
cursor_y = cons_newline(cursor_y, sheet);
} else if (cmdline[0] != 0) {
/* コマンドではなく、さらに空行でもない */
putfonts8_asc_sht(sheet, 8, cursor_y, COL8_FFFFFF, COL8_000000, "Bad command.", 12);
cursor_y = cons_newline(cursor_y, sheet);
cursor_y = cons_newline(cursor_y, sheet);
}
/* プロンプト表示 */
putfonts8_asc_sht(sheet, 8, cursor_y, COL8_FFFFFF, COL8_000000, ">", 1);
cursor_x = 16;
} else {
/* 一般文字 */
if (cursor_x < 240) {
/* 一文字表示してから、カーソルを1つ進める */
s[0] = i - 256;
s[1] = 0;
cmdline[cursor_x / 8 - 2] = i - 256;
putfonts8_asc_sht(sheet, cursor_x, cursor_y, COL8_FFFFFF, COL8_000000, s, 1);
cursor_x += 8;
}
}
}
/* カーソル再表示 */
if (cursor_c >= 0) {
boxfill8(sheet->buf, sheet->bxsize, cursor_c, cursor_x, cursor_y, cursor_x + 7, cursor_y + 15);
}
sheet_refresh(sheet, cursor_x, cursor_y, cursor_x + 8, cursor_y + 16);
}
}
}
void console_task (struct SHEET *sheet, unsigned int memtotal)
{
struct TIMER *timer;
struct TASK *task = task_now ();
int i, fifobuf[128];
char s[30], cmdline[30];
struct MEMMAN *memman = (struct MEMMAN *)MEMMAN_ADDR;
struct CONSOLE cons;
cons.sht = sheet;
cons.cur_x = 8;
cons.cur_y = 28;
cons.cur_c = -1;
int *fat = (int *)memman_alloc_4k (memman, 4 * 2880);
file_readfat (fat, (unsigned char *)(ADR_DISKIMG + 0x000200));
fifo32_init (&task->fifo, 128, fifobuf, task);
timer = timer_alloc ();
timer_init (timer, &task->fifo, 1);
timer_settime (timer, 50);
cons_putchar (&cons, '>', 1);
for (;;) {
io_cli();
if (fifo32_status (&task->fifo) == 0) {
task_sleep(task);
io_sti ();
} else {
i = fifo32_get (&task->fifo);
io_sti ();
if (i <= 1) { /* timer for cursor */
if (i != 0) {
timer_init (timer, &task->fifo, 0);
if (cons.cur_c >= 0) {
cons.cur_c = COL8_FFFFFF;
}
} else {
timer_init (timer, &task->fifo, 1);
if (cons.cur_c >= 0) {
cons.cur_c = COL8_000000;
}
}
timer_settime (timer, 50);
}
if (i == 2) { // Cursor ON
cons.cur_c = COL8_FFFFFF;
}
if (i == 3) { // Cursor OFF
boxfill8 (sheet->buf, sheet->bxsize, COL8_000000, cons.cur_x, 28, cons.cur_x + 7, 43);
cons.cur_c = -1;
}
if (256 <= i && i <= 511) { /* Keyboard data from Task-A */
if (i == 8 + 256) {
// Backspace
if (cons.cur_x > 16) {
putfonts8_asc_sht(sheet, cons.cur_x, cons.cur_y, COL8_FFFFFF, COL8_000000, " ", 1);
cons.cur_x -= 8;
}
} else if (i == 10 + 256) {
// Enter
cons_putchar (&cons, ' ', 0);
putfonts8_asc_sht (sheet, cons.cur_x, cons.cur_y, COL8_FFFFFF, COL8_000000, " ", 1);
cmdline[cons.cur_x / 8 - 2] = 0;
cons_newline (&cons);
// Execute Command
cons_runcmd (cmdline, &cons, fat, memtotal);
cons_putchar (&cons, '>', 1);
} else {
// Normal charactor
if (cons.cur_x < 240) {
s[0] = i - 256;
s[1] = 0;
cmdline[cons.cur_x / 8 - 2] = i - 256;
putfonts8_asc_sht(sheet, cons.cur_x, cons.cur_y, COL8_FFFFFF, COL8_000000, s, 1);
cons.cur_x += 8;
}
}
}
if (cons.cur_c >= 0) {
boxfill8 (sheet->buf, sheet->bxsize, cons.cur_c, cons.cur_x, cons.cur_y, cons.cur_x + 7, cons.cur_y + 15);
}
sheet_refresh (sheet, cons.cur_x, cons.cur_y, cons.cur_x + 8, cons.cur_y + 16);
}
}
}
void console_task(struct SHEET *sheet, int memtotal)
{
struct TASK *task = task_now();
struct MEMMAN *memman = (struct MEMMAN *) MEMMAN_ADDR;
int i, *fat = (int *) memman_alloc_4k(memman, 4 * 2880);
struct CONSOLE cons;
struct FILEHANDLE fhandle[8];
char cmdline[30];
cons.sht = sheet;
cons.cur_x = 8;
cons.cur_y = 28;
cons.cur_c = -1;
task->cons = &cons;
if (cons.sht != 0) {
cons.timer = timer_alloc();
timer_init(cons.timer, &task->fifo, 1);
timer_settime(cons.timer, 50);
}
file_readfat(fat, (unsigned char *) (ADR_DISKIMG + 0x000200));
for (i = 0; i < 8; i++) {
fhandle[i].buf = 0; /* 未使用マーク */
}
task->fhandle = fhandle;
task->fat = fat;
/* プロンプト表示 */
cons_putchar(&cons, '>', 1);
for (;;) {
io_cli();
if (fifo32_status(&task->fifo) == 0) {
task_sleep(task);
io_sti();
} else {
i = fifo32_get(&task->fifo);
io_sti();
if (i <= 1 && cons.sht != 0) { /* カーソル用タイマ */
if (i != 0) {
timer_init(cons.timer, &task->fifo, 0); /* 次は0を */
if (cons.cur_c >= 0) {
cons.cur_c = COL8_FFFFFF;
}
} else {
timer_init(cons.timer, &task->fifo, 1); /* 次は1を */
if (cons.cur_c >= 0) {
cons.cur_c = COL8_000000;
}
}
timer_settime(cons.timer, 50);
}
if (i == 2) { /* カーソルON */
cons.cur_c = COL8_FFFFFF;
}
if (i == 3) { /* カーソルOFF */
if (cons.sht != 0) {
boxfill8(cons.sht->buf, cons.sht->bxsize, COL8_000000,
cons.cur_x, cons.cur_y, cons.cur_x + 7, cons.cur_y + 15);
}
cons.cur_c = -1;
}
if (i == 4) { /* コンソールの「×」ボタンクリック */
cmd_exit(&cons, fat);
}
if (256 <= i && i <= 511) { /* キーボードデータ（タスクA経由） */
if (i == 8 + 256) {
/* バックスペース */
if (cons.cur_x > 16) {
/* カーソルをスペースで消してから、カーソルを1つ戻す */
cons_putchar(&cons, ' ', 0);
cons.cur_x -= 8;
}
} else if (i == 10 + 256) {
/* Enter */
/* カーソルをスペースで消してから改行する */
cons_putchar(&cons, ' ', 0);
cmdline[cons.cur_x / 8 - 2] = 0;
cons_newline(&cons);
cons_runcmd(cmdline, &cons, fat, memtotal); /* コマンド実行 */
if (cons.sht == 0) {
cmd_exit(&cons, fat);
}
/* プロンプト表示 */
cons_putchar(&cons, '>', 1);
} else {
/* 一般文字 */
if (cons.cur_x < 240) {
/* 一文字表示してから、カーソルを1つ進める */
cmdline[cons.cur_x / 8 - 2] = i - 256;
cons_putchar(&cons, i - 256, 1);
}
}
}
/* カーソル再表示 */
if (cons.sht != 0) {
if (cons.cur_c >= 0) {
boxfill8(cons.sht->buf, cons.sht->bxsize, cons.cur_c,
cons.cur_x, cons.cur_y, cons.cur_x + 7, cons.cur_y + 15);
}
sheet_refresh(cons.sht, cons.cur_x, cons.cur_y, cons.cur_x + 8, cons.cur_y + 16);
}
}
}
}
void HariMain(void)
{
/*
**最初的这部分变量没有通过内存管理来分配，它们本身属于操作系统的一部分，存在于bootpack.hrb所在的那块儿内存空间中
*/
BOOTINFO *binfo = (BOOTINFO *) ADR_BOOTINFO;
MOUSE_DECODE mouse_dec;
MEMMANAGE *memmanage = (MEMMANAGE *)MEMMANAGE_ADDR;
LAYER_MANAGE *layer_manage;
LAYER *layer_bg, *layer_mouse;
FIFO fifo_mutual; //缓冲区管理，所有中断公用的
FIFO keycmd_fifo;
TASK *task_a, *task; //后面的那个task只是作为一个临时变量来用的
int fifobuf[128], keycmd_buf[32], *console_fifo[2]; //缓冲区
int mCursorX, mCursorY; //鼠标光标显示位置的横纵坐标
int key_shift = 0, key_ctrl = 0, key_leds = (binfo->leds >> 4) & 7, keycmd_wait = -1; //标志键盘输入到哪个窗口中
int j, x, y, last_mcursorX = -1, last_mcursorY= -1, tmp_layerX = 0; //last_mcursorX这两个变量记录的是鼠标移动之前的坐标
int new_mcursorX = -1, new_mcursorY = 0, new_layerX = 0x7fffffff, new_layerY = 0;
LAYER *layer = 0, *key_to_window, *layer_to_free; //key_to_window这个变量记录当前的键盘输入到哪个窗口中
unsigned int memory_total, i;
unsigned char buf_cursor[mCursorWidth * mCursorHeight];
unsigned char *buf_bg; //屏幕的大背景会在init_screen的时候画出来，这里只需要一个指向它的指针即可
char strings[40];
int *fat;
unsigned char *hzset;
FILEINFO *finfo;
extern char charset[4096];
mCursorX = binfo->scrnx / 2;
mCursorY = (binfo->scrny - 28)/ 2; //减去下方任务栏的高度
/*初始化GDT和IDT表以及PIC板的数据*/
init_GDTandIDT(); //初始化GDT和IDT表
init_pic(); //初始化PIC主从板数据，除了IRQ2禁止了全部中断
io_sti(); //开始接收中断
init_fifo(&keycmd_fifo, 32, keycmd_buf, 0);
/*初始化接收中断的缓冲区*/
init_fifo(&fifo_mutual, 128, fifobuf, 0); //初始化mouseFIFO缓冲区，现在还没任务，先指定为0
/*初始化PIT中断控制*/
init_PIT();
/*若要接收鼠标中断需要两个步骤，首先必须使鼠标控制电路（就是键盘控制电路的一部分）有效，然后要使鼠标本身有效*/
init_keyboard(&fifo_mutual, 256); //初始化键盘控制器电路
enable_mouse(&fifo_mutual, 512, &mouse_dec); //激活鼠标
/*开放各种中断*/
io_out8(PIC0_IMR, 0xf8); //PIC0开发IRQ(11111000)，开放IRQ0、IRQ1和IRQ2，定时器、键盘中断和从PIC板
io_out8(PIC1_IMR, 0xef); //PIC1开放IRQ(11101111)， 开放鼠标中断
/*内存检查*/
i = memtest(0x00400000, 0xbfffffff) / (1024 * 1024); //i的单位是MB
/*内存管理*/
memmanage_init(memmanage);
memory_total = i * 1024 * 1024;
memmanage_free_4K(memmanage, 0x00001000, 0x0009e000);
memmanage_free_4K(memmanage, 0x00400000, memory_total - 0x00400000);
/*初始化调色板，为图形界面做准备*/
init_palette(); //初始化调色板
/*初始化图层管理，并且初始化鼠标光标和背景的图层*/
layer_manage = layer_man_init(memmanage, binfo->vram, binfo->scrnx, binfo->scrny);
*((int *) 0x0fe4) = (int) layer_manage;
/*初始化任务切换管理*/
task_a = task_init(memmanage); //这个task_a其实代表的就是这些鼠标键盘等的任务
fifo_mutual.task = task_a; //为鼠标键盘等的缓冲区指定唤醒任务为task_a
task_run(task_a, 1, 2);
task_a->lanmode = 0; //默认的语言模式是英文模式
layer_bg = layer_alloc(layer_manage); //为背景分配图层
layer_mouse = layer_alloc(layer_manage); //为鼠标分配图层
buf_bg = (unsigned char *)memmanage_alloc_4K(memmanage, binfo->scrnx * binfo->scrny); //为背景图形的内容分配内存
/*为各个图形的图层内容进行设定*/
layer_set(layer_bg, buf_bg, binfo->scrnx, binfo->scrny, -1);
layer_set(layer_mouse, buf_cursor, 16, 16 ,99);
/*初始化整个桌面背景*/
init_screen(buf_bg, binfo->scrnx, binfo->scrny); //这个时候的init_screen不再是直接画出背景，而是在mBg内存地址中填写好背景内容
layer_slide(layer_bg, 0, 0); //把背景图层从(0,0)坐标开始画
/*初始化鼠标图标*/
init_mouse_cursor(buf_cursor, 99); //初始化鼠标光标
layer_slide(layer_mouse, mCursorX, mCursorY); //现在显示图形不需要再用displayShape函数了，直接用这个图层管理的绘图函数就行
/*载入汉字字符库*/
fat = (int *)memmanage_alloc_4K(memmanage, 4 * 2880);
file_readfat(fat, (unsigned char *)(ADR_DISKIMG + 0x000200));
finfo = file_search("hzset.fnt", (FILEINFO *)(ADR_DISKIMG + 0x002600), 224);
//找到这个字符库文件的话，就把字符库载入
if(0 != finfo)
{
i = finfo->size; //为了防止finfo->size的值被修改，用了i做中间变量
hzset = file_load_tekfile(finfo->clusterno, &i, fat); //函数内部就已经给要解压的文件分配好了内存
}
//找不到字符库文件的话，就把内置英文字符库载入，后面的字符全部用方块（0xff）填充
else
{
hzset = (unsigned char *)memmanage_alloc_4K(memmanage, 16 * 256 + 32 * 5170); //共256个半角英文字符，5170个全角中文字符
for(i = 0; i < 16 * 256; i++)
{
hzset[i] = charset[i];
}
for(i = 16 * 256; i < 16 * 256 + 32 * 5170; i++)
{
hzset[i] = 0xff;
}
}
*((int *) 0x0fe8) = (int)hzset;
memmanage_free_4K(memmanage,(int)fat, 4 * 2880);
/*执行一个命令行窗口任务*/
key_to_window = open_console(layer_manage, memory_total); //最初的时候由第一个console接收键盘输入
layer_slide(key_to_window, 8, 2);
/*设置好各个图层的高度*/
layer_switch(layer_bg, 0); //把背景图层调为最底层，高度为0
layer_switch(key_to_window, 1); //命令行窗口图层调节为第三层，高度为2
layer_switch(layer_mouse, 2); //鼠标图层调为最高层，高度为3
keywindow_on(key_to_window);
//
fifo_put(&keycmd_fifo, KEYCMD_LED);
fifo_put(&keycmd_fifo, key_leds);
*((int *) 0x0fec) = (int) &fifo_mutual;
for(;;)
{
if(fifo_status(&keycmd_fifo) > 0 && keycmd_wait < 0)
{
keycmd_wait = fifo_get(&keycmd_fifo);
wait_KBC_sendready();
io_out8(PORT_KEYDATA, keycmd_wait);
}
/*只有在从中断返回的缓冲区中读取数据的时候才需要禁止中断，因为如果这个时候来了中断而没有禁止的话，
**有可能读脏数据，即把还没有读出的数据的给抹掉或换成别的数据
*/
io_cli();
if(0 == fifo_status(&fifo_mutual)) //当前没有中断产生
{
//利用CPU空闲的时间来执行耗时的绘图工作(这样的话会造成反应很快的表象，但其实，如果中断很多，尤其是鼠标中断很多的时候，
//会把之前记录下的new_mcursorX覆盖掉，而只绘制最新的图层坐标)
if(new_mcursorX >= 0)
{
io_sti();
layer_slide(layer_mouse, new_mcursorX, new_mcursorY);
new_mcursorX = -1; //绘制完鼠标之后，就把它的坐标设置为负数，反正鼠标不会出去屏幕，为负数的时候就说明不需要重绘鼠标
}
//图层的横坐标为0x7fffffff的时候就不需要重绘了，这是作为一个标志的，它为其他值的时候就需要重绘了
else if(new_layerX != 0x7fffffff)
{
io_sti();
layer_slide(layer, new_layerX, new_layerY);
new_layerX = 0x7fffffff;
}
//如果不需要重绘鼠标和图层的话，就没有什么工作可做了，进入休眠就可以了
else
{
task_sleep(task_a); //如果没有需要处理的数据，就自己让自己休眠
/*上面的那个函数直接就跳转到另一个任务中去了，不过，因为每个人物的默认eflags都是开启中断的，
**所以不用担心，这个任务还是能被唤醒的，耳环醒后的第一个动作就是为了以防万一先开启中断
*/
io_sti(); //万一只有自己在运行的话，则无法睡眠，那么就执行hlt指令好了，这样省电嘛
}
}
else
{
i = fifo_get(&fifo_mutual);
io_sti();
//窗口被关闭的情况
if(0 != key_to_window && 0 == key_to_window->flags)
{
//如果当前画面上只剩下鼠标和背景的时候
if(1 == layer_manage->top)
{
key_to_window = 0;
}
else
{
key_to_window = layer_manage->layers_order[layer_manage->top - 1]; //当窗口被关闭的时候，自动切换成最上层的layer接收键盘输入
keywindow_on(key_to_window);
}
}
/*
**有一点需要注意，键盘输入只能由console来接收，如果只剩下task_a任务了，那么这个主任务就只接收打开窗口console的输入
**其他输入一律不处理，否则会陷入死循环
*/
//如果是键盘中断的话，需要处理键盘发送来的中断数据
if((keyboard_offset <= i) && (i <= keyboard_offset + 255))
{
//判断shift键是否按下，然后使用不同的keytable表
if(i < 0x80 + keyboard_offset)
{
if(0 == key_shift)
{
strings[0] = key_table[i - keyboard_offset];
}
else
{
strings[0] = key_table_shift[i - keyboard_offset];
}
}
else
{
strings[0] = 0;
}
//判断Caps和Shift键的情况以确定输入大写还是小写字母
if('A' <= strings[0] && strings[0] <= 'Z')
{
//小写字母的情况
if((0 == (key_leds & 4) && 0 == key_shift) || (0 != (key_leds & 4) && 0 != key_shift))
{
strings[0] += 0x20;
}
}
//判断按下的字符是否为一般字符，0对应的字符不处理，对退格键和回车键加上了对应字符，他们对应的table表里的元素不再是0
//切记key_to_window也就是当前的键盘输入接收图层不能使layer_bg，因为这会造成死循环一直向task_a的fifo中无限填充刚刚输入的字符
if(strings[0] != 0 && key_to_window != 0 && key_to_window != layer_bg)
{
fifo_put(&key_to_window->task->fifo, strings[0] + 256);
}
/*这些都是那些不能打印的特殊按键，它们对应的都是0*/
//按下“TAB键”的处理情况，切换输入窗口
if(i == keyboard_offset + 0x0f && key_to_window != 0 && key_to_window != layer_bg)
{
//先让当前的窗口的光标OFF掉
keywindow_off(key_to_window);
j = key_to_window->height - 1;
if(0 == j)
{
//如果切换之后的图层是最底层的操作系统的图层，那么就切换成最上层的图层
j = layer_manage->top - 1;
}
key_to_window = layer_manage->layers_order[j];
//使切换到的窗口的光标ON
keywindow_on(key_to_window);
}
//左或右Ctrl ON
if(0x1d + keyboard_offset == i)
{
key_ctrl = 1;
}
//左或右Ctrl OFF
if(0x9d + keyboard_offset == i)
{
key_ctrl = 0;
}
//左shift ON
if(0x2a + keyboard_offset == i)
{
key_shift |= 1;
}
//右shift ON
if(0x36 + keyboard_offset == i)
{
key_shift |= 2;
}
//左shift OFF
if(0xaa + keyboard_offset == i)
{
key_shift &= ~1;
}
//左shift OFF
if(0xb6 + keyboard_offset == i)
{
key_shift &= ~2;
}
/*对各种锁定键的处理*/
//CapsLock键
if(i == keyboard_offset + 0x3a)
{
key_leds ^= 4;
fifo_put(&keycmd_fifo, KEYCMD_LED);
fifo_put(&keycmd_fifo, key_leds);
}
//NumLock键
if(i == keyboard_offset + 0x45)
{
key_leds ^= 2;
fifo_put(&keycmd_fifo, KEYCMD_LED);
fifo_put(&keycmd_fifo, key_leds);
}
//ScrollLock键
if(i == keyboard_offset + 0x46)
{
key_leds ^= 1;
fifo_put(&keycmd_fifo, KEYCMD_LED);
fifo_put(&keycmd_fifo, key_leds);
}
//如果按下了F2，那么就关闭应用程序
if((i == keyboard_offset + 0x3C) && key_to_window != 0 && key_to_window != layer_bg)
{
task = key_to_window->task; //找到当前接收键盘输入的（即最前面的）图层所对应的任务
if(0 != task && task->tss.ss0 != 0)
{
console_putstring_toend(task->console, "\nTerminate program! :\n");
io_cli();
//让CPU直接跳转到console中执行，不再管应用程序，也就是所谓的停止应用程序继续运行
task->tss.eax = (int) &(task->tss.esp0);
task->tss.eip = (int) asm_end_app;
io_sti();
/*其实在console任务没有什么中断可处理的时候就会进入休眠，强制结束的时候需要先唤醒它，让他执行结束程序处理
**但是不唤醒的话，在这个应用程序对应的console窗口有显示的时候也可以停止，只是它需要由定时器每隔0.5秒来唤醒一次
**所以看起来反应并不及时，最大反应时间为0.5秒
*/
task_run(task, -1, 0);
}
}
//如果按下了F1，就打开一个console
if((i == keyboard_offset + 0x3B))
{
if(key_to_window != 0)
{
keywindow_off(key_to_window);
}
key_to_window = open_console(layer_manage, memory_total);
layer_slide(key_to_window, 300, 2);
layer_switch(key_to_window, layer_manage->top);
//自动把键盘输入切换到这个新打开的console中
keywindow_on(key_to_window);
}
//键盘成功接收到数据
if(i == keyboard_offset + 0xfa)
{
keycmd_wait = -1;
}
//键盘没有成功接收到数据
if(i == keyboard_offset + 0xfe)
{
wait_KBC_sendready();
io_out8(PORT_KEYDATA, keycmd_wait);
}
}
//如果是鼠标中断的话，需要处理鼠标发送来的中断数据
else if((mouse_offset <= i) && (i <= mouse_offset + 255))
{
if(0 != mouse_decode(&mouse_dec, i - mouse_offset)) //只有返回值为1的时候才说明成功接收完成一次鼠标的中断
{
/*鼠标的移动*/
//根据mouse_dec里存储的鼠标信息画出新的鼠标图像
mCursorX += mouse_dec.x;
mCursorY += mouse_dec.y;
//不能让鼠标移出画面
if(mCursorX < 0)
{
mCursorX = 0;
}
if(mCursorY < 0)
{
mCursorY = 0;
}
if(mCursorX > binfo->scrnx - 1)
{
mCursorX = binfo->scrnx - 1;
}
if(mCursorY > binfo->scrny - 1)
{
mCursorY = binfo->scrny - 1;
}
//记录下鼠标光标的移动到的位置，等待fifo中为空的时候开始绘图
new_mcursorX = mCursorX;
new_mcursorY = mCursorY;
//按下了左键
if(0 != (mouse_dec.btn & 0x01))
{
//如果last_mcursorX小于0，说明当前不是处于窗口移动模式，那么就需要检查现在鼠标按下左键之后有没有落在某个图层的标题栏上
if(last_mcursorX < 0)
{
for(j = layer_manage->top - 1; j > 0; j--)
{
layer = layer_manage->layers_order[j];
//计算一下鼠标的坐标在不在这个图层里面
x = mCursorX - layer->x;
y = mCursorY - layer->y;
if(0 <= x && x < layer->length && 0 <= y && y <= layer->width)
{
//鼠标所在区域也不能是涂层的透明区域
if(layer->buffer[y * layer->length + x] != layer->color_luc)
{
layer_switch(layer, layer_manage->top - 1);
//如果当前的layer不是接收键盘输入的图层（即最前面的图层），那么就需要切换
if(layer != key_to_window)
{
//鼠标左击窗口所做的事情跟按下TAB键的事情差不多
keywindow_off(key_to_window);
key_to_window = layer;
keywindow_on(key_to_window);
}
//查看鼠标当前点击的区域是不是窗口的标题栏，并且不能是关闭按钮所在的区域
if(3 <= x && x < layer->length - 21 && 3 <= y && y <= 21)
{
last_mcursorX = mCursorX;
last_mcursorY = mCursorY;
tmp_layerX = layer->x; //这个tmp_layerX只是个要绘制的图层横坐标的过渡部分，真正的坐标还需要处理
new_layerY = layer->y;
}
//这个是鼠标点击到关闭按钮的情况
if(layer->length - 21 <= x && x <= layer->length - 5 && 5 <= y && y <= 19)
{
//查看该窗口是否为应用程序的窗口，如果是应用程序产生的窗口而不是console的那个黑窗口，那么这个窗口的flags有0x10
if(0 != (layer->flags & 0x10))
{
//这部分处理跟按下ctrl+x的处理基本一样
task = layer->task;
console_putstring_toend(task->console, "Break by mouse!\n");
io_cli();
task->tss.eax = (int)&(task->tss.esp0);
task->tss.eip = (int)asm_end_app;
io_sti();
task_run(task, -1, 0);
}
//不是应用程序的话就是console命令行窗口产生的layer
else
{
//不能再这里的task_a中直接关闭，因为还有些console自身管理的定时器和fat等东西无法释放了
task = layer->task;
/*这里只是暂时隐藏console的图层，因为对于有的应用程序的命令行窗口关闭需要消耗很多时间，
**所以为了让用户感觉关闭的很快，就先隐藏，具体的释放等费时的工作交给后面做
*/
layer_switch(layer, -1);
keywindow_off(key_to_window);
key_to_window = layer_manage->layers_order[layer_manage->top - 1];
keywindow_on(key_to_window);
io_cli();
fifo_put(&task->fifo, 4);
io_sti();
}
}
break;
}
}
}
}
//只要last_mcursorX大于0，说明当前处于窗口移动模式，说明当前鼠标正点击着某个图层的标题栏呢
else
{
x = mCursorX - last_mcursorX;
y = mCursorY - last_mcursorY;
new_layerX = (tmp_layerX + x + 2) & ~3;
new_layerY = new_layerY + y;
last_mcursorY = mCursorY; //更新到移动后的坐标
}
}
//如果当前没有按下左键，就把last_mcursorX设置为负数，作为当前不处于窗口移动的依据
else
{
last_mcursorX = -1;
if(0x7fffffff != new_layerX)
{
layer_slide(layer, new_layerX, new_layerY); //一旦鼠标不点击这窗口移动了，就立即最后一次绘制窗口并且停止窗口的移动
new_layerX = 0x7fffffff;
}
}
}
}
//收到这个之间的数据，说明是让关闭console的
else if(768 <= i && i <= 1023)
{
close_console(layer_manage->layers + (i - 768));
}
//关闭命令行的任务
else if(1024 <= i && i <= 2023)
{
close_console_task(taskctl->tasks + (i - 1024));
}
//关闭命令行窗口（释放它的图层）
else if(2024 <= i && i <= 2279) //图层最多只有256个，加上偏移量之后就是这个范围了
{
layer_to_free = layer_manage->layers + (i - 2024);
memmanage_free_4K(memmanage, (int) layer_to_free->buffer, 256 * 265);
layer_free(layer_to_free);
}
}
}
}
//命令行窗口任务
void console_task(LAYER *layer, unsigned int mem_total)
{
TIMER *timer;
TASK *task = task_now();
int i, fifobuf[128];
MEMMANAGE *memmanage = (MEMMANAGE *)MEMMANAGE_ADDR;
int *fat = (int *)memmanage_alloc_4K(memmanage, 4 * 2880); //用来存储FAT表的内存地址
char cmdline[30]; //cmdline用来记录在命令行中输入的命令
CONSOLE console;
console.layer = layer;
console.cursor_x = 16;
console.cursor_y = 28;
console.cursor_color = -1;
*((int *) 0x0fec) = (int)&console;
file_readfat(fat, (unsigned char *)(ADR_DISKIMG + 0x000200)); //FAT表从第3个扇区开始，占用了共9个扇区
init_fifo(&task->fifo, 128, fifobuf, task);
timer = timer_alloc();
timer_init(timer, &task->fifo, 1);
timer_set(timer, 50);
//显示提示字符
displayStrings_atLayer(layer, 8, 28, COL8_FFFFFF, COL8_000000, ">");
for(;;)
{
io_cli();
if(0 == fifo_status(&task->fifo))
{
task_sleep(task);
io_sti();
}
else
{
//这里传出来的i直接就是键盘的对应键的字符加上一个键盘偏移量，不需要再转化了，只需要减去偏移量即可
i = fifo_get(&task->fifo);
io_sti();
//计时器的中断数据处理（在这里就是光标的闪烁）
if(1 == i || 0 == i) //等于1或者0
{
if(1 == i)
{
if(console.cursor_color >= 0)
{
console.cursor_color = COL8_FFFFFF;
}
timer_init(timer, &task->fifo, 0);
}
else
{
if(console.cursor_color >= 0)
{
console.cursor_color = COL8_000000;
}
timer_init(timer, &task->fifo, 1);
}
timer_set(timer, 50);
}
//光标ON
if(2 == i)
{
console.cursor_color = COL8_FFFFFF;
}
//光标OFF
if(3 == i)
{
drawRectangle(layer->buffer, layer->length, COL8_000000, console.cursor_x, console.cursor_y, 2, 15);
console.cursor_color = -1;
}
//键盘数据的处理(主要是命令的处理)
if(keyboard_offset <= i && i <= keyboard_offset + 255)
{
//如果是“退格键”的情况
if(8 + keyboard_offset == i)
{
//不能删除最前面的提示符，而且只能在有字符的时候才能删除
if(console.cursor_x > 16)
{
//首先用空格擦除光标，光标横坐标减8之后，再把要删除的那个字符用空格擦除
console_putchar(&console, ' ', 0);
console.cursor_x -= 8;
console_putchar(&console, ' ', 0);
}
}
//如果是“回车键”的情况
else if(10 + keyboard_offset == i)
{
console_putchar(&console, ' ', 0);
cmdline[console.cursor_x / 8 - 2] = 0;
console_newline(&console);
//运行命令
console_runcmd(cmdline, &console, fat, mem_total);
//显示提示字符
console_putchar(&console, '>', 1);
}
//如果是一般字符的情况
else
{
if(console.cursor_x < 240)
{
cmdline[console.cursor_x / 8 - 2] = i - keyboard_offset;
console_putchar(&console, i - keyboard_offset, 1);
}
}
}
//重新显示光标
if(console.cursor_color >= 0)
{
drawRectangle(layer->buffer, layer->length, console.cursor_color, console.cursor_x, console.cursor_y, 2, 15);
}
layer_part_refresh(layer, console.cursor_x, console.cursor_y, console.cursor_x + 8, console.cursor_y + 16);
}
}
}
// sht: a sheet
void task_console(struct SHEET * sht,unsigned int memtotal)
{
//struct FIFO fifo;
struct TIMER *timer;
int i, fifobuf[128];
char s[30],cmdline[30];
struct CONSOLE cons;
cons.sht = sht;
cons.cur_x = 8;
cons.cur_y = 28;
cons.cur_c = -1;
struct MEMMAN * memman = (struct MEMMAN *) MEMMAN_ADDR;
int *fat = (int *) memman_alloc_4k(memman, 4 * 2880);
file_readfat(fat, (unsigned char *) (ADR_DISKIMG + 0x000200));
* (int *) 0x0fec = (int) &cons;
int count=0;
struct TASK *task = task_now();
timer = timer_alloc();
timer_set(timer,50,&task->fifo,1);
fifo_init(&task->fifo,128,fifobuf,task);
cons_putchar(&cons, '$', 1);
for(;;)
{
count++;
io_cli();
if(fifo_status(&task->fifo) == 0)
{
task_sleep(task);
io_sti();
}
else
{
i = fifo_get(&task->fifo);
io_sti();
if(i <= 1)
{
if(i== 1)
{
timer_set(timer,50,&task->fifo,0);
if(cons.cur_c >= 0)
cons.cur_c = COL8_FFFFFF;
}
else
{
timer_set(timer,50,&task->fifo,1);
if(cons.cur_c >= 0)
cons.cur_c = COL8_000084;
}
}
if(i ==2 )
cons.cur_c = COL8_FFFFFF;
if(i ==3) // cursor off
{
boxfill8(sht->buf,sht->bxsize, COL8_000084,cons.cur_x, cons.cur_y,cons.cur_x + 7, cons.cur_y+15);
cons.cur_c = -1;
}
if (256 <= i && i <= 511) // keyboard data
{
if(i == 8 + 256)
{ // backspace
if (cons.cur_x >= 16) {
cons_putchar(&cons, ' ', 0); // erase the cursor
cons.cur_x -= 8;
}
}
else if(i == 10 + 256) { // enter key
cons_putchar(&cons, ' ', 0); // disable cursor
cmdline[cons.cur_x/8 -2] = 0; // construct string
cons_newline(&cons); // next line
cons_runcmd(cmdline,&cons,fat,memtotal);
cons_putchar(&cons, '$', 1);
}
else // general character
{
if(cons.cur_x < 240) {
cmdline[cons.cur_x/8 -2] = i-256;
cons_putchar(&cons, i-256, 1);
}
//else
//{
//cons.cur_x = 16;
//cons.cur_y +=16;
//cmdline[cons.cur_x/8 -2] = i-256; // 16 starts char
//cons_putchar(&cons, i-256, 1);
//}
}
}
if(cons.cur_c >= 0)
boxfill8(sht->buf,sht->bxsize, cons.cur_c,cons.cur_x, cons.cur_y,cons.cur_x + 7, cons.cur_y+15);
sheet_refresh(sht,cons.cur_x,cons.cur_y,cons.cur_x + 8, cons.cur_y + 16);
}
}
}
void HariMain(void)
{
int mmx = -1, mmy = -1, mmx2 = 0;
struct SHEET *sht = 0, *key_win;
struct BOOTINFO *binfo = (struct BOOTINFO *)0x0ff0;
int xsize = (*binfo).scrnx;
int ysize = (*binfo).scrny;
int mx = xsize/2;
int my = ysize/2;
int new_mx = -1, new_my = 0, new_wx = 0x7fffffff, new_wy = 0;
int fifobuf[128], keycmd_buf[32], *cons_fifo[2];
struct MOUSE_DEC mdec;
unsigned char s[32];
unsigned int memtotal;
struct MEMMAN *memman = (struct MEMMAN *)MEMMAN_ADDR;
int key_shift = 0, key_leds = (binfo->leds >> 4) & 7, keycmd_wait = -1;
struct SHTCTL *shtctl;
struct SHEET *sht_back, *sht_mouse;
unsigned char *buf_back, buf_mouse[256], *buf_cons[2];
struct TIMER *timer;
struct FIFO32 fifo, keycmd;
struct TASK *task_a, *task_cons[2];
static char keytable0[0x80] = {
0, 0, '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '-', '^', 0x08, 0,
'Q', 'W', 'E', 'R', 'T', 'Y', 'U', 'I', 'O', 'P', '@', '[', 0x0a, 0, 'A', 'S',
'D', 'F', 'G', 'H', 'J', 'K', 'L', ';', ':', 0, 0, ']', 'Z', 'X', 'C', 'V',
'B', 'N', 'M', ',', '.', '/', 0, '*', 0, ' ', 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, '7', '8', '9', '-', '4', '5', '6', '+', '1',
'2', '3', '0', '.', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0x5c, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x5c, 0, 0
};
static char keytable1[0x80] = {
0, 0, '!', 0x22, '#', '$', '%', '&', 0x27, '(', ')', '~', '=', '~', '|', 0,
'Q', 'W', 'E', 'R', 'T', 'Y', 'U', 'I', 'O', 'P', '`', '{', 0x0a, 0, 'A', 'S',
'D', 'F', 'G', 'H', 'J', 'K', 'L', '+', '*', 0, 0, '}', 'Z', 'X', 'C', 'V',
'B', 'N', 'M', '<', '>', '?', 0, '*', 0, ' ', 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, '7', '8', '9', '-', '4', '5', '6', '+', '1',
'2', '3', '0', '.', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, '_', 0, 0, 0, 0, 0, 0, 0, 0, 0, '|', 0, 0
};
extern char hankaku[4096];
init_gdtidt ();
init_pic ();
io_sti ();
fifo32_init(&fifo, 32, fifobuf, 0);
fifo32_init(&keycmd, 32, keycmd_buf, 0);
init_pit();
io_out8(PIC0_IMR, 0xf8); /* Allow PIT and Keyboard (11111000) */
io_out8(PIC1_IMR, 0xef); /* Allow Mouse (11101111) */
init_keyboard (&fifo, 256);
enable_mouse (&fifo, 512, &mdec);
timer = timer_alloc();
timer_init(timer, &fifo, 1);
timer_settime(timer, 50);
memtotal = memtest(0x00400000, 0xbfffffff);
memman_init (memman);
memman_free (memman, 0x00001000, 0x009e000); /* 0x00001000 - 0x0009efff */
memman_free (memman, 0x00400000, memtotal - 0x00400000);
init_pallete();
shtctl = shtctl_init (memman, binfo->vram, binfo->scrnx, binfo->scrny);
sht_back = sheet_alloc(shtctl);
sht_mouse = sheet_alloc(shtctl);
buf_back = (unsigned char *)memman_alloc_4k (memman, binfo->scrnx * binfo->scrny);
sheet_setbuf (sht_back, buf_back, binfo->scrnx, binfo->scrny, -1);
sheet_setbuf (sht_mouse, buf_mouse, 16, 16, 99);
init_screen (buf_back, xsize, ysize);
init_mouse_cursor8 (buf_mouse, 99);
*((int *) 0x0fec) = (int) &fifo;
//=====================
// Task Settings
//=====================
task_a = task_init(memman);
fifo.task = task_a;
task_a->langmode = 0;
task_run (task_a, 1, 0);
/* console sheet */
key_win = open_console (shtctl, memtotal);
//=======================
// Sheet Setting
//=======================
*((int *) 0x0fe4) = (int) shtctl;
sheet_slide (sht_back, 0, 0);
sheet_slide (key_win, 32, 4);
sheet_slide (sht_mouse, mx, my);
sheet_updown (sht_back, 0);
sheet_updown (key_win, 1);
sheet_updown (sht_mouse, 2);
sheet_refresh (sht_back, 0, 0, binfo->scrnx, 48);
keywin_on (key_win);
fifo32_put (&keycmd, KEYCMD_LED);
fifo32_put (&keycmd, key_leds);
/* Reading nihongo.fnt */
unsigned char *nihongo = (unsigned char *)memman_alloc_4k (memman, 16 * 256 + 32 * 94 * 47);
int *fat = (int *)memman_alloc_4k (memman, 4 * 2880);
file_readfat (fat, (unsigned char *)(ADR_DISKIMG + 0x000200));
struct FILEINFO *finfo = file_search ("nihongo.fnt", (struct FILEINFO *)(ADR_DISKIMG + 0x002600), 224);
if (finfo != 0) {
int i = finfo->size;
nihongo = file_loadfile2 (finfo->clustno, &i, fat);
} else {
nihongo = (unsigned char *)memman_alloc_4k (memman, 16 * 256 + 32 * 94 * 47);
for (int i = 0; i < 16 * 256; i++) {
nihongo[i] = hankaku[i];
}
for (int i = 16 * 256; i < 16 * 256 + 32 * 94 * 47; i++) {
nihongo[i] = 0xff;
}
}
*((int *)0x0fe8) = (int) nihongo;
memman_free_4k (memman, (int) fat, 4 * 2880);
for (;;) {
if (fifo32_status(&keycmd) > 0 && keycmd_wait < 0) {
keycmd_wait = fifo32_get(&keycmd);
wait_KBC_sendready ();
io_out8(PORT_KEYDAT, keycmd_wait);
}
io_cli();
if (fifo32_status(&fifo) == 0) {
/* execute draw if FIFO is empty */
if (new_mx >= 0) {
io_sti ();
sheet_slide (sht_mouse, new_mx, new_my);
new_mx = -1;
} else if (new_wx != 0x7fffffff) {
io_sti ();
sheet_slide (sht, new_wx, new_wy);
new_wx = 0x7fffffff;
} else {
task_sleep(task_a);
io_sti();
}
} else {
int i = fifo32_get(&fifo);
io_sti();
if (key_win != 0 && key_win->flags == 0) { // input Window is closed
if (shtctl->top == 1) { // ony mouse and background
key_win = 0;
} else {
key_win = shtctl->sheets[shtctl->top - 1];
keywin_on (key_win);
}
}
if (256 <= i && i <= 511) { // Keyboard Data
if (i < 0x80 + 256) {
if (key_shift == 0) {
s[0] = keytable0[i - 256];
} else {
s[0] = keytable1[i - 256];
}
} else {
s[0] = 0;
}
if ('A' <= s[0] && s[0] <= 'Z') {
if (((key_leds & 4) == 0 && key_shift == 0) ||
((key_leds & 4) != 0 && key_shift != 0)) {
s[0] += 0x20;
}
}
if (s[0] != 0 && key_win != 0) {
fifo32_put(&key_win->task->fifo, s[0] + 256);
}
if (i == 256 + 0x0f && key_win != 0) { // Tab
keywin_off (key_win);
int j = key_win->height - 1;
if (j == 0) {
j = shtctl->top - 1;
}
key_win = shtctl->sheets[j];
keywin_on (key_win);
}
if (i == 256 + 0x2a) { // Left Shift ON
key_shift |= 1;
}
if (i == 256 + 0x36) { // Right Shift ON
key_shift |= 2;
}
if (i == 256 + 0xaa) { // Left Shift OFF
key_shift &= ~1;
}
if (i == 256 + 0xb6) { // Right Shift ON
key_shift &= ~2;
}
if (i == 256 + 0x3a) { // CapsLock
key_leds ^= 4;
fifo32_put(&keycmd, KEYCMD_LED);
fifo32_put(&keycmd, key_leds);
}
if (i == 256 + 0x45) { // NumLock
key_leds ^= 2;
fifo32_put(&keycmd, KEYCMD_LED);
fifo32_put(&keycmd, key_leds);
}
if (i == 256 + 0x46) { // ScrollLock
key_leds ^= 1;
fifo32_put(&keycmd, KEYCMD_LED);
fifo32_put(&keycmd, key_leds);
}
if (i == 256 + 0x3b && key_shift != 0 && key_win != 0) {
struct TASK *task = key_win->task;
if (task != 0 && task->tss.ss0 != 0) { /* Shift+F1 */
cons_putstr0 (task->cons, "\nBreak(key) : \n");
io_cli ();
task->tss.eax = (int) &(task->tss.esp0);
task->tss.eip = (int) asm_end_app;
io_sti ();
task_run (task, -1, 0);
}
}
if (i == 256 + 0x3c && key_shift != 0) { /* Shift+F2 */
if (key_win != 0) {
keywin_off (key_win);
}
key_win = open_console (shtctl, memtotal);
sheet_slide (key_win, 32, 4);
sheet_updown (key_win, shtctl->top);
keywin_on (key_win);
}
if (i == 256 + 0x57) { /* F11 */
sheet_updown (shtctl->sheets[1], shtctl->top-1);
}
if (i == 256 + 0xfa) { // KeyBoard receive Data
keycmd_wait = -1;
}
if (i == 256 + 0xfe) { // KeyBoard failed to receive Data
wait_KBC_sendready ();
io_out8(PORT_KEYDAT, keycmd_wait);
}
} else if (512 <= i && i <= 767) { // Mouse Data
if (mouse_decode(&mdec, i-512) != 0) {
mx += mdec.x;
my += mdec.y;
if (mx < 0) { mx = 0; } if (mx > binfo->scrnx - 1) { mx = binfo->scrnx - 1; }
if (my < 0) { my = 0; } if (my > binfo->scrny - 1) { my = binfo->scrny - 1; }
// sprintf(s, "(%d, %d)", mx, my);
// putfonts8_asc_sht (sht_back, 0, 0, COL8_FFFFFF, COL8_008484, s, 10);
sheet_slide (sht_mouse, mx, my);
new_mx = mx;
new_my = my;
if ((mdec.btn & 0x01) != 0) {
/* Left Mouse Button is down */
if (mmx < 0) {
/* Normal Mode */
for (int j = shtctl->top - 1; j > 0; j--) {
sht = shtctl->sheets[j];
int x = mx - sht->vx0;
int y = my - sht->vy0;
if (0 <= x && x < sht->bxsize && 0 <= y && y < sht->bysize) {
if (sht->buf[y * sht->bxsize + x] != sht->col_inv) {
sheet_updown (sht, shtctl->top - 1);
if (sht != key_win) {
keywin_off (key_win);
key_win = sht;
keywin_on (key_win);
}
if (3 <= x && x < sht->bxsize - 3 && 3 <= y && y < 21) {
mmx = mx;
mmy = my;
mmx2 = sht->vx0;
new_wy = sht->vy0;
}
if (sht->bxsize - 21 <= x && x < sht->bxsize - 5 && 5 <= y && y < 19) {
// "X" button is clicked
if ((sht->flags & 0x10) != 0) {
// Window is made by Application?
struct TASK *task = sht->task;
cons_putstr0 (task->cons, "\nBreak(mouse) :\n");
io_cli ();
task->tss.eax = (int) & (task->tss.esp0);
task->tss.eip = (int) asm_end_app;
io_sti ();
task_run (task, -1, 0);
} else {
struct TASK *task = sht->task;
sheet_updown (sht, -1);
keywin_off (key_win);
key_win = shtctl->sheets[shtctl->top-1];
keywin_off (key_win);
io_cli ();
fifo32_put (&task->fifo, 4);
io_sti ();
}
}
break;
}
}
}
} else {
// Moving window mode
int x = mx - mmx;
int y = my - mmy;
new_wx = (mmx2 + x + 2) & ~3;
new_wy = new_wy + y;
mmy = my;
}
} else {
mmx = -1;
if (new_wx != 0x7fffffff) {
sheet_slide (sht, new_wx, new_wy);
new_wx = 0x7fffffff;
}
}
}
} else if (768 <= i && i <= 1023) {
close_console (shtctl->sheets0 + (i - 768));
} else if (1024 <= i && i < 2023) {
close_constask (taskctl->tasks0 + (i - 1024));
} else if (2024 <= i && i <= 2279) {
struct SHEET *sht2 = shtctl->sheets0 + (i - 2024);
memman_free_4k (memman, (int)sht2->buf, 256 * 165);
sheet_free (sht2);
}
}
}
}
void
console_task(layer_t* layer, unsigned int mem_total)
{
#define INPUT_BEG_POS_X (24)
#define INPUT_BEG_POS_Y (28)
#define PROMPT_CHAR ("> ")
#define PROMPT_LEN (2)
timer_t* timer;
task_t* task = task_now();
int data, fifobuf[128];
int cursor_x = INPUT_BEG_POS_X, cursor_y = INPUT_BEG_POS_Y;
int cursor_c = -1;
char buf[32], cmdline[32];
mem_mgr_t* memmgr = (mem_mgr_t*)MEMMGR_ADDR;
segment_descriptor_t* gdt = (segment_descriptor_t*)ADR_GDT;
int* fat = (int*)mem_mgr_alloc_4k(memmgr, 4 * 2880);
file_readfat(fat, (unsigned char*)(ADR_DISKIMG + 0x000200));
fifo_init(&task->fifo, fifobuf, 128, task);
timer = timer_alloc();
timer_init(timer, &task->fifo, 1);
timer_settimer(timer, 50);
/* display the prompt of console window */
drawstring_and_refresh(layer, 8, 28,
COLOR8_FFFFFF, COLOR8_000000, PROMPT_CHAR, PROMPT_LEN);
for ( ; ; ) {
io_cli();
if (0 == fifo_size(&task->fifo)) {
task_sleep(task);
io_sti();
}
else {
data = fifo_get(&task->fifo);
io_sti();
if (data <= 1) {
/* timer for cursor */
if (0 != data) {
timer_init(timer, &task->fifo, 0);
if (cursor_c >= 0)
cursor_c = COLOR8_FFFFFF;
}
else {
timer_init(timer, &task->fifo, 1);
if (cursor_c >= 0)
cursor_c = COLOR8_000000;
}
timer_settimer(timer, 50);
}
if (2 == data) /* cursor ON */
cursor_c = COLOR8_FFFFFF;
if (3 == data) { /* cursor OFF */
fill_box8(layer->buf, layer->w_size,
COLOR8_000000, cursor_x, 28, cursor_x + 7, cursor_y + 15);
cursor_c = -1;
}
if (256 <= data && data <= 511) {
/* keyboard data */
if ((8 + 256) == data) {
/* backspace */
if (cursor_x > INPUT_BEG_POS_X) {
/* erase the cursor and move forward one character */
drawstring_and_refresh(layer, cursor_x, cursor_y,
COLOR8_FFFFFF, COLOR8_000000, " ", 1);
cursor_x -= 8;
}
}
else if ((10 + 256) == data) {
/* Enter Key */
/* erase cursor by space */
drawstring_and_refresh(layer, cursor_x, cursor_y,
COLOR8_FFFFFF, COLOR8_000000, " ", 1);
cmdline[cursor_x / 8 - 3] = 0;
cursor_y = console_newline(cursor_y, layer);
/* execute command */
if (0 == strcmp("mem", cmdline)) {
/* check memory command */
cursor_y = memory_command(layer, memmgr, mem_total, cursor_y);
}
else if (0 == strcmp("clear", cmdline)) {
/* clear command */
cursor_y = clear_command(layer);
}
else if (0 == strcmp("ls", cmdline)) {
/* ls(dir) command */
cursor_y = list_command(layer, cursor_y);
}
else if (0 == strncmp("cat ", cmdline, 4)) {
/* cat command */
cursor_y = cat_command(memmgr,
layer, fat, cursor_x, cursor_y, cmdline);
}
else if (0 == strcmp("hlt", cmdline)) {
/* run hlt application */
cursor_y = hlt_command(gdt, memmgr, layer, fat, cursor_y);
}
else if (0 != cmdline[0]) {
/* neither command nor null string */
drawstring_and_refresh(layer, 8, cursor_y,
COLOR8_FFFFFF, COLOR8_000000, "Bad Command.", 12);
cursor_y = console_newline(cursor_y, layer);
cursor_y = console_newline(cursor_y, layer);
}
/* show prompt */
drawstring_and_refresh(layer, 8, cursor_y,
COLOR8_FFFFFF, COLOR8_000000, PROMPT_CHAR, PROMPT_LEN);
cursor_x = INPUT_BEG_POS_X;
}
else {
/* general character */
if (cursor_x < 240) {
/* display one character and move backward one character */
buf[0] = data - 256;
buf[1] = 0;
cmdline[cursor_x / 8 - 3] = data - 256;
drawstring_and_refresh(layer, cursor_x, cursor_y,
COLOR8_FFFFFF, COLOR8_000000, buf, 1);
cursor_x += 8;
}
}
}
/* show the cursor again */
if (cursor_c >= 0) {
fill_box8(layer->buf, layer->w_size,
cursor_c, cursor_x, cursor_y, cursor_x + 7, cursor_y + 15);
}
layers_refresh(layer, cursor_x, cursor_y,
cursor_x + 8, cursor_y + 16);
}
}
}
void console_task(struct SHEET *sheet, unsigned int memtotal)
{
struct TIMER *timer;
struct TASK *task = task_now();
struct MEMMAN *memman = (struct MEMMAN *) MEMMAN_ADDR;
int i, fifobuf[128], *fat = (int *) memman_alloc_4k(memman, 4 * 2880);
struct CONSOLE cons;
char cmdline[30];
cons.sht = sheet;
cons.cur_x = 8;
cons.cur_y = 28;
cons.cur_c = -1;
fifo32_init(&task->fifo, 128, fifobuf, task);
timer = timer_alloc();
timer_init(timer, &task->fifo, 1);
timer_settime(timer, 50);
file_readfat(fat, (unsigned char *) (ADR_DISKIMG + 0x000200));
cons_putchar(&cons, '>', 1);
for (;;) {
io_cli();
if (fifo32_status(&task->fifo) == 0) {
task_sleep(task);
io_sti();
} else {
i = fifo32_get(&task->fifo);
io_sti();
if (i <= 1) {
if (i != 0) {
timer_init(timer, &task->fifo, 0);
if (cons.cur_c >= 0) {
cons.cur_c = COL8_FFFFFF;
}
} else {
timer_init(timer, &task->fifo, 1);
if (cons.cur_c >= 0) {
cons.cur_c = COL8_000000;
}
}
timer_settime(timer, 50);
}
if (i == 2) {
cons.cur_c = COL8_FFFFFF;
}
if (i == 3) {
boxfill8(sheet->buf, sheet->bxsize, COL8_000000, cons.cur_x, cons.cur_y, cons.cur_x + 7, cons.cur_y + 15);
cons.cur_c = -1;
}
if (256 <= i && i <= 511) {
if (i == 8 + 256) {
if (cons.cur_x > 16) {
cons_putchar(&cons, ' ', 0);
cons.cur_x -= 8;
}
} else if (i == 10 + 256) {
cons_putchar(&cons, ' ', 0);
cmdline[cons.cur_x / 8 - 2] = 0;
cons_newline(&cons);
cons_runcmd(cmdline, &cons, fat, memtotal);
cons_putchar(&cons, '>', 1);
} else {
if (cons.cur_x < 240) {
cmdline[cons.cur_x / 8 - 2] = i - 256;
cons_putchar(&cons, i - 256, 1);
}
}
}
if (cons.cur_c >= 0) {
boxfill8(sheet->buf, sheet->bxsize, cons.cur_c, cons.cur_x, cons.cur_y, cons.cur_x + 7, cons.cur_y + 15);
}
sheet_refresh(sheet, cons.cur_x, cons.cur_y, cons.cur_x + 8, cons.cur_y + 16);
}
}
}
void HariMain(void)
{
struct BOOTINFO *binfo = (struct BOOTINFO *) ADR_BOOTINFO;
struct SHTCTL *shtctl;
char s[40];
struct FIFO32 fifo, keycmd;
int fifobuf[128], keycmd_buf[32];
int mx, my, i, new_mx = -1, new_my = 0, new_wx = 0x7fffffff, new_wy = 0;
unsigned int memtotal;
struct MOUSE_DEC mdec;
struct MEMMAN *memman = (struct MEMMAN *) MEMMAN_ADDR;
unsigned char *buf_back, buf_mouse[256];
struct SHEET *sht_back, *sht_mouse;
struct TASK *task_a, *task;
static char keytable0[0x80] = {
0, 0, '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '-', '^', 0x08, 0,
'Q', 'W', 'E', 'R', 'T', 'Y', 'U', 'I', 'O', 'P', '@', '[', 0x0a, 0, 'A', 'S',
'D', 'F', 'G', 'H', 'J', 'K', 'L', ';', ':', 0, 0, ']', 'Z', 'X', 'C', 'V',
'B', 'N', 'M', ',', '.', '/', 0, '*', 0, ' ', 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, '7', '8', '9', '-', '4', '5', '6', '+', '1',
'2', '3', '0', '.', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0x5c, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x5c, 0, 0
};
static char keytable1[0x80] = {
0, 0, '!', 0x22, '#', '$', '%', '&', 0x27, '(', ')', '~', '=', '~', 0x08, 0,
'Q', 'W', 'E', 'R', 'T', 'Y', 'U', 'I', 'O', 'P', '`', '{', 0x0a, 0, 'A', 'S',
'D', 'F', 'G', 'H', 'J', 'K', 'L', '+', '*', 0, 0, '}', 'Z', 'X', 'C', 'V',
'B', 'N', 'M', '<', '>', '?', 0, '*', 0, ' ', 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, '7', '8', '9', '-', '4', '5', '6', '+', '1',
'2', '3', '0', '.', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, '_', 0, 0, 0, 0, 0, 0, 0, 0, 0, '|', 0, 0
};
int key_shift = 0, key_leds = (binfo->leds >> 4) & 7, keycmd_wait = -1;
int j, x, y, mmx = -1, mmy = -1, mmx2 = 0;
struct SHEET *sht = 0, *key_win, *sht2;
int *fat;
unsigned char *nihongo;
struct FILEINFO *finfo;
extern char hankaku[4096];
init_gdtidt();
init_pic();
io_sti(); /* IDT/PIC的初始化已经完成，于是开放CPU的中断 */
fifo32_init(&fifo, 128, fifobuf, 0);
*((int *) 0x0fec) = (int) &fifo;
init_pit();
init_keyboard(&fifo, 256);
enable_mouse(&fifo, 512, &mdec);
io_out8(PIC0_IMR, 0xf8); /* 设定PIT和PIC1以及键盘为许可(11111000) */
io_out8(PIC1_IMR, 0xef); /* 开放鼠标中断(11101111) */
fifo32_init(&keycmd, 32, keycmd_buf, 0);
memtotal = memtest(0x00400000, 0xbfffffff);
memman_init(memman);
memman_free(memman, 0x00001000, 0x0009e000); /* 0x00001000 - 0x0009efff */
memman_free(memman, 0x00400000, memtotal - 0x00400000);
init_palette();
shtctl = shtctl_init(memman, binfo->vram, binfo->scrnx, binfo->scrny);
task_a = task_init(memman);
fifo.task = task_a;
task_run(task_a, 1, 2);
*((int *) 0x0fe4) = (int) shtctl;
task_a->langmode = 0;
/* sht_back */
sht_back = sheet_alloc(shtctl);
buf_back = (unsigned char *) memman_alloc_4k(memman, binfo->scrnx * binfo->scrny);
sheet_setbuf(sht_back, buf_back, binfo->scrnx, binfo->scrny, -1); /* 无透明色 */
init_screen8(buf_back, binfo->scrnx, binfo->scrny);
/* sht_cons */
key_win = open_console(shtctl, memtotal);
/* sht_mouse */
sht_mouse = sheet_alloc(shtctl);
sheet_setbuf(sht_mouse, buf_mouse, 16, 16, 99);
init_mouse_cursor8(buf_mouse, 99);
mx = (binfo->scrnx - 16) / 2; /* 计算坐标使其位于画面中央 */
my = (binfo->scrny - 28 - 16) / 2;
sheet_slide(sht_back, 0, 0);
sheet_slide(key_win, 32, 4);
sheet_slide(sht_mouse, mx, my);
sheet_updown(sht_back, 0);
sheet_updown(key_win, 1);
sheet_updown(sht_mouse, 2);
keywin_on(key_win);
/* 为了避免和键盘当前状态冲突，在一开始先进行设置 */
fifo32_put(&keycmd, KEYCMD_LED);
fifo32_put(&keycmd, key_leds);
/* 载入nihongo.fnt */
fat = (int *) memman_alloc_4k(memman, 4 * 2880);
file_readfat(fat, (unsigned char *) (ADR_DISKIMG + 0x000200));
finfo = file_search("nihongo.fnt", (struct FILEINFO *) (ADR_DISKIMG + 0x002600), 224);
if (finfo != 0) {
i = finfo->size;
nihongo = file_loadfile2(finfo->clustno, &i, fat);
} else {
nihongo = (unsigned char *) memman_alloc_4k(memman, 16 * 256 + 32 * 94 * 47);
for (i = 0; i < 16 * 256; i++) {
nihongo[i] = hankaku[i]; /*没有字库，半角部分直接复制英文字库*/
}
for (i = 16 * 256; i < 16 * 256 + 32 * 94 * 47; i++) {
nihongo[i] = 0xff; /* 没有字库，全角部分以0xff填充 */
}
}
*((int *) 0x0fe8) = (int) nihongo;
memman_free_4k(memman, (int) fat, 4 * 2880);
for (;;) {
if (fifo32_status(&keycmd) > 0 && keycmd_wait < 0) {
/* 如果存在向键盘控制器发送的数据，则发送它 */
keycmd_wait = fifo32_get(&keycmd);
wait_KBC_sendready();
io_out8(PORT_KEYDAT, keycmd_wait);
}
io_cli();
if (fifo32_status(&fifo) == 0) {
/* FIFO为空，当存在搁置的绘图操作时立即执行*/
if (new_mx >= 0) {
io_sti();
sheet_slide(sht_mouse, new_mx, new_my);
new_mx = -1;
} else if (new_wx != 0x7fffffff) {
io_sti();
sheet_slide(sht, new_wx, new_wy);
new_wx = 0x7fffffff;
} else {
task_sleep(task_a);
io_sti();
}
} else {
i = fifo32_get(&fifo);
io_sti();
if (key_win != 0 && key_win->flags == 0) { /*窗口被关闭*/
if (shtctl->top == 1) { /*当画面上只剩鼠标和背景时*/
key_win = 0;
} else {
key_win = shtctl->sheets[shtctl->top - 1];
keywin_on(key_win);
}
}
if (256 <= i && i <= 511) { /* 键盘数据*/
if (i < 0x80 + 256) { /*将按键编码转换为字符编码*/
if (key_shift == 0) {
s[0] = keytable0[i - 256];
} else {
s[0] = keytable1[i - 256];
}
} else {
s[0] = 0;
}
if ('A' <= s[0] && s[0] <= 'Z') { /*当输入字符为英文字母时*/
if (((key_leds & 4) == 0 && key_shift == 0) ||
((key_leds & 4) != 0 && key_shift != 0)) {
s[0] += 0x20; /*将大写字母转换为小写字母*/
}
}
if (s[0] != 0 && key_win != 0) { /*一般字符、退格键、回车键*/
fifo32_put(&key_win->task->fifo, s[0] + 256);
}
if (i == 256 + 0x0f && key_win != 0) { /* Tab键 */
keywin_off(key_win);
j = key_win->height - 1;
if (j == 0) {
j = shtctl->top - 1;
}
key_win = shtctl->sheets[j];
keywin_on(key_win);
}
if (i == 256 + 0x2a) { /*左Shift ON */
key_shift |= 1;
}
if (i == 256 + 0x36) { /*右Shift ON */
key_shift |= 2;
}
if (i == 256 + 0xaa) { /*左Shift OFF */
key_shift &= ~1;
}
if (i == 256 + 0xb6) { /*右Shift OFF */
key_shift &= ~2;
}
if (i == 256 + 0x3a) { /* CapsLock */
key_leds ^= 4;
fifo32_put(&keycmd, KEYCMD_LED);
fifo32_put(&keycmd, key_leds);
}
if (i == 256 + 0x45) { /* NumLock */
key_leds ^= 2;
fifo32_put(&keycmd, KEYCMD_LED);
fifo32_put(&keycmd, key_leds);
}
if (i == 256 + 0x46) { /* ScrollLock */
key_leds ^= 1;
fifo32_put(&keycmd, KEYCMD_LED);
fifo32_put(&keycmd, key_leds);
}
if (i == 256 + 0x3b && key_shift != 0 && key_win != 0) { /* Shift+F1 */
task = key_win->task;
if (task != 0 && task->tss.ss0 != 0) {
cons_putstr0(task->cons, "\nBreak(key) :\n");
io_cli(); /*强制结束处理时禁止任务切换*/
task->tss.eax = (int) &(task->tss.esp0);
task->tss.eip = (int) asm_end_app;
io_sti();
task_run(task, -1, 0); /*为了确实执行结束处理，如果处于休眠状态则唤醒*/
}
}
if (i == 256 + 0x3c && key_shift != 0) { /* Shift+F2 */
if (key_win != 0) {
keywin_off(key_win);
}
key_win = open_console(shtctl, memtotal);
sheet_slide(key_win, 32, 4);
sheet_updown(key_win, shtctl->top);
keywin_on(key_win);
}
if (i == 256 + 0x57) { /* F11 */
sheet_updown(shtctl->sheets[1], shtctl->top - 1);
}
if (i == 256 + 0xfa) { /*键盘成功接收到数据*/
keycmd_wait = -1;
}
if (i == 256 + 0xfe) { /*键盘没有成功接收到数据*/
wait_KBC_sendready();
io_out8(PORT_KEYDAT, keycmd_wait);
}
} else if (512 <= i && i <= 767) { /* 鼠标数据*/
if (mouse_decode(&mdec, i - 512) != 0) {
/* 已经收集了3字节的数据，移动光标 */
mx += mdec.x;
my += mdec.y;
if (mx < 0) {
mx = 0;
}
if (my < 0) {
my = 0;
}
if (mx > binfo->scrnx - 1) {
mx = binfo->scrnx - 1;
}
if (my > binfo->scrny - 1) {
my = binfo->scrny - 1;
}
new_mx = mx;
new_my = my;
if ((mdec.btn & 0x01) != 0) { /* 按下左键 */
if (mmx < 0) {
/*如果处于通常模式*/
/*按照从上到下的顺序寻找鼠标所指向的图层*/
for (j = shtctl->top - 1; j > 0; j--) {
sht = shtctl->sheets[j];
x = mx - sht->vx0;
y = my - sht->vy0;
if (0 <= x && x < sht->bxsize && 0 <= y && y < sht->bysize) {
if (sht->buf[y * sht->bxsize + x] != sht->col_inv) {
sheet_updown(sht, shtctl->top - 1);
if (sht != key_win) {
keywin_off(key_win);
key_win = sht;
keywin_on(key_win);
}
if (3 <= x && x < sht->bxsize - 3 && 3 <= y && y < 21) {
mmx = mx; /*进入窗口移动模式*/
mmy = my;
mmx2 = sht->vx0;
new_wy = sht->vy0;
}
if (sht->bxsize - 21 <= x && x < sht->bxsize - 5 && 5 <= y && y < 19) {
/*点击“×”按钮*/
if ((sht->flags & 0x10) != 0) { /*该窗口是否为应用程序窗口？*/
task = sht->task;
cons_putstr0(task->cons, "\nBreak(mouse) :\n");
io_cli(); /*强制结束处理时禁止任务切换*/
task->tss.eax = (int) &(task->tss.esp0);
task->tss.eip = (int) asm_end_app;
io_sti();
task_run(task, -1, 0);
} else { /*命令行窗口*/
task = sht->task;
sheet_updown(sht, -1); /*暂且隐藏该图层*/
keywin_off(key_win);
key_win = shtctl->sheets[shtctl->top - 1];
keywin_on(key_win);
io_cli();
fifo32_put(&task->fifo, 4);
io_sti();
}
}
break;
}
}
}
} else {
/*如果处于窗口移动模式*/
x = mx - mmx; /*计算鼠标指针移动量*/
y = my - mmy;
new_wx = (mmx2 + x + 2) & ~3;
new_wy = new_wy + y;
mmy = my;
}
} else {
/*没有按下左键*/
mmx = -1; /*切换到一般模式*/
if (new_wx != 0x7fffffff) {
sheet_slide(sht, new_wx, new_wy); /*固定图层位置*/
new_wx = 0x7fffffff;
}
}
}
} else if (768 <= i && i <= 1023) { /*命令行窗口关闭处理*/
close_console(shtctl->sheets0 + (i - 768));
} else if (1024 <= i && i <= 2023) {
close_constask(taskctl->tasks0 + (i - 1024));
} else if (2024 <= i && i <= 2279) { /*只关闭命令行窗口*/
sht2 = shtctl->sheets0 + (i - 2024);
memman_free_4k(memman, (int) sht2->buf, 256 * 165);
sheet_free(sht2);
}
}
}
}
/* 控制台任务 */
void console_task(struct SHEET *sheet, unsigned int memtotal)
{
struct TIMER *timer;
struct TASK *task = task_now();
int i, fifobuf[128], cursor_x = 16, cursor_y = 28, cursor_c = -1;
char s[30], cmdline[30], *p;
struct MEMMAN *memman = (struct MEMMAN *) MEMMAN_ADDR;
int x, y;
struct FILEINFO *finfo = (struct FILEINFO *) (ADR_DISKIMG + 0x002600);
int *fat = (int *) memman_alloc_4k(memman, 4 * 2880);
struct SEGMENT_DESCRIPTOR *gdt = (struct SEGMENT_DESCRIPTOR *) ADR_GDT;
fifo32_init(&task->fifo, 128, fifobuf, task);
timer = timer_alloc();
timer_init(timer, &task->fifo, 1);
timer_settime(timer, 50);
file_readfat(fat, (unsigned char *) (ADR_DISKIMG + 0x000200));
/* 输出一个">" */
putfonts8_asc_sht(sheet, 8, 28, COL8_FFFFFF, COL8_000000, ">", 1);
for (;;) {
io_cli();
if (fifo32_status(&task->fifo) == 0) { /* 控制台任务自己的缓冲区中没有数据 */
task_sleep(task); /* 睡眠自己 */
io_sti();
} else {
i = fifo32_get(&task->fifo); /* 读出数据 */
io_sti();
if (i <= 1) { /* 光标用定时器 */
if (i != 0) {
timer_init(timer, &task->fifo, 0); /* 下面是设定0 */
if (cursor_c >= 0) { /* 如果需要显示光标 */
cursor_c = COL8_FFFFFF;
}
} else {
timer_init(timer, &task->fifo, 1); /* 下面是设定1 */
if (cursor_c >= 0) { /* 如果需要显示光标 */
cursor_c = COL8_000000;
}
}
timer_settime(timer, 50); /* 设置半秒 */
}
if (i == 2) { /* 光标ON */
cursor_c = COL8_FFFFFF;
}
if (i == 3) { /* 光标OFF */
/* 直接用黑色将原来光标的位置消去 */
boxfill8(sheet->buf, sheet->bxsize, COL8_000000, cursor_x, cursor_y, cursor_x + 7, cursor_y + 15);
cursor_c = -1;
}
if (256 <= i && i <= 511) { /* 任务A传送过来的键盘的数据 */
if (i == 8 + 256) { /* 注意！在任务A中已经将键值转换成字符的ASCII码了 */
/* 退格键 */
if (cursor_x > 16) {
/* 用空格把光标消去之后 光标向左移8个像素点 */
putfonts8_asc_sht(sheet, cursor_x, cursor_y, COL8_FFFFFF, COL8_000000, " ", 1);
cursor_x -= 8;
}
} else if (i == 10 + 256) { /* 如果是回车 (10是换行符的ASCII码) */
/* Enter */
/* 用空格将光标擦除 */
putfonts8_asc_sht(sheet, cursor_x, cursor_y, COL8_FFFFFF, COL8_000000, " ", 1);
cmdline[cursor_x / 8 - 2] = 0; /* 计算前面有几个字符 在字符的后面加上'\0' */
/* 加'\0'是因为C语言中字符串都是以它结尾的 */
/* 减2是减去'\0'的位置还有一个回车的位置 所*/
/* 以最后'\0'是刚好在最后一个字符后面 */
cursor_y = cons_newline(cursor_y, sheet); /* 换行 */
/* 执行命令 */
if (strcmp(cmdline, "mem") == 0) {
/* mem命令 */
/* 输出内存总大小和空闲内存大小 */
sprintf(s, "total %dMB", memtotal / (1024 * 1024));
putfonts8_asc_sht(sheet, 8, cursor_y, COL8_FFFFFF, COL8_000000, s, 30);
cursor_y = cons_newline(cursor_y, sheet); /* 换行 */
sprintf(s, "free %dKB", memman_total(memman) / 1024);
putfonts8_asc_sht(sheet, 8, cursor_y, COL8_FFFFFF, COL8_000000, s, 30);
cursor_y = cons_newline(cursor_y, sheet); /* 换行 */
cursor_y = cons_newline(cursor_y, sheet); /* 换行 */
} else if (strcmp(cmdline, "cls") == 0) {
/* cls命令 */
/* 最简单。。每个像素都设为黑色..... */
for (y = 28; y < 28 + 128; y++) {
for (x = 8; x < 8 + 240; x++) {
sheet->buf[x + y * sheet->bxsize] = COL8_000000;
}
}
sheet_refresh(sheet, 8, 28, 8 + 240, 28 + 128);
cursor_y = 28;
} else if (strcmp(cmdline, "dir") == 0) {
/* dir命令 */
for (x = 0; x < 224; x++) { /* 遍历所有的根目录条目 */
/* 这个224是在ipl10中定义的 */
if (finfo[x].name[0] == 0x00) { /* 该条目不包含任何文件信息 */
break;
}
if (finfo[x].name[0] != 0xe5) { /* 该条目包含文件信息 */
if ((finfo[x].type & 0x18) == 0) { /* 该条目记录的不是目录 也不是非文件信息 */
sprintf(s, "filename.ext %7d", finfo[x].size);
for (y = 0; y < 8; y++) { /* 设置文件名 */
s[y] = finfo[x].name[y];
}
s[ 9] = finfo[x].ext[0]; /* 设置扩展名 */
s[10] = finfo[x].ext[1];
s[11] = finfo[x].ext[2];
putfonts8_asc_sht(sheet, 8, cursor_y, COL8_FFFFFF, COL8_000000, s, 30);
cursor_y = cons_newline(cursor_y, sheet); /* 换行 */
}
}
}
cursor_y = cons_newline(cursor_y, sheet); /* 换行 */
} else if (strncmp(cmdline, "type ", 5) == 0) {
/* type命令 */
/* 准备文件名 */
for (y = 0; y < 11; y++) {
s[y] = ' ';
}
y = 0;
for (x = 5; y < 11 && cmdline[x] != 0; x++) {
if (cmdline[x] == '.' && y <= 8) {
y = 8;
} else {
s[y] = cmdline[x];
if ('a' <= s[y] && s[y] <= 'z') {
/* 将小写字母转换成大写字母 */
s[y] -= 0x20;
}
y++;
}
}
/* 寻找文件 */
for (x = 0; x < 224; ) {
if (finfo[x].name[0] == 0x00) { /* 该条目不包含任何文件信息 */
break;
}
if ((finfo[x].type & 0x18) == 0) { /* 该条目记录的不是目录 也不是非文件信息 */
for (y = 0; y < 11; y++) {
if (finfo[x].name[y] != s[y]) {
goto type_next_file;
}
}
break; /* 找到文件就退出循环 */
}
type_next_file:
x++;
}
if (x < 224 && finfo[x].name[0] != 0x00) {
/* 找到文件的情况 */
/* 分配内存 这块内存用于存放文件的内容 */
p = (char *) memman_alloc_4k(memman, finfo[x].size);
/* 将软盘中该文件的内容复制到p指向的内存中 */
file_loadfile(finfo[x].clustno, finfo[x].size, p, fat, (char *) (ADR_DISKIMG + 0x003e00));
cursor_x = 8;
for (y = 0; y < finfo[x].size; y++) {
/* 逐个输出文件中的内容 */
s[0] = p[y];
s[1] = 0;
if (s[0] == 0x09) { /* 制表符 */
for (;;) {
/* 这一小段就不注释了，偷下懒 书中解释的很详细 */
putfonts8_asc_sht(sheet, cursor_x, cursor_y, COL8_FFFFFF, COL8_000000, " ", 1);
cursor_x += 8;
if (cursor_x == 8 + 240) {
cursor_x = 8;
cursor_y = cons_newline(cursor_y, sheet);
}
if (((cursor_x - 8) & 0x1f) == 0) {
break; /* 被32整除则break */
}
}
} else if (s[0] == 0x0a) { /* 换行 */
cursor_x = 8;
cursor_y = cons_newline(cursor_y, sheet);
} else if (s[0] == 0x0d) { /* 回车 */
/* 忽略 */
} else { /* 一般字符 */
putfonts8_asc_sht(sheet, cursor_x, cursor_y, COL8_FFFFFF, COL8_000000, s, 1);
cursor_x += 8;
if (cursor_x == 8 + 240) {
cursor_x = 8;
cursor_y = cons_newline(cursor_y, sheet);
}
}
}
/* 输出完毕 将刚申请的内存空间释放掉 */
memman_free_4k(memman, (int) p, finfo[x].size);
} else { /* 文件没有找到 */
putfonts8_asc_sht(sheet, 8, cursor_y, COL8_FFFFFF, COL8_000000, "File not found.", 15);
cursor_y = cons_newline(cursor_y, sheet);
}
cursor_y = cons_newline(cursor_y, sheet);
} else if (strcmp(cmdline, "hlt") == 0) { /* 调用应用程序 */
for (y = 0; y < 11; y++) {
s[y] = ' ';
}
/* 设置文件名 */
s[0] = 'H';
s[1] = 'L';
s[2] = 'T';
s[8] = 'H';
s[9] = 'R';
s[10] = 'B';
/* 查找文件 */
for (x = 0; x < 224; ) {
if (finfo[x].name[0] == 0x00) {
break;
}
if ((finfo[x].type & 0x18) == 0) {
for (y = 0; y < 11; y++) {
if (finfo[x].name[y] != s[y]) {
goto hlt_next_file;
}
}
break; /* 找到文件 */
}
hlt_next_file:
x++;
}
if (x < 224 && finfo[x].name[0] != 0x00) {
/* 找到文件的情况 */
/* 分配一块内存 文件将被加载到这个并执行 */
p = (char *) memman_alloc_4k(memman, finfo[x].size);
/* 将文件的内容复制到p指向的缓冲区 */
file_loadfile(finfo[x].clustno, finfo[x].size, p, fat, (char *) (ADR_DISKIMG + 0x003e00));
/* 为我们的应用程序创建一个描述符 */
set_segmdesc(gdt + 1003, finfo[x].size - 1, (int) p, AR_CODE32_ER);
/* 跳转到应用程序执行 */
farjmp(0, 1003 * 8);
/* 释放内存 */
memman_free_4k(memman, (int) p, finfo[x].size);
} else {
/* 文件没有找到 */
putfonts8_asc_sht(sheet, 8, cursor_y, COL8_FFFFFF, COL8_000000, "File not found.", 15);
cursor_y = cons_newline(cursor_y, sheet);
}
cursor_y = cons_newline(cursor_y, sheet);
} else if (cmdline[0] != 0) {
/* 控制台有输入但不是上面的命令 */
putfonts8_asc_sht(sheet, 8, cursor_y, COL8_FFFFFF, COL8_000000, "Bad command.", 12);
cursor_y = cons_newline(cursor_y, sheet);
cursor_y = cons_newline(cursor_y, sheet);
}
/* 输出一个'>' */
putfonts8_asc_sht(sheet, 8, cursor_y, COL8_FFFFFF, COL8_000000, ">", 1);
cursor_x = 16;
} else {
/* 一般字符 */
if (cursor_x < 240) {
/* 显示一个字符后光标向右移8个像素点 */
s[0] = i - 256;
s[1] = 0;
cmdline[cursor_x / 8 - 2] = i - 256;
putfonts8_asc_sht(sheet, cursor_x, cursor_y, COL8_FFFFFF, COL8_000000, s, 1);
cursor_x += 8;
}
}
}
/* 如果需要显示光标 */
if (cursor_c >= 0) {
boxfill8(sheet->buf, sheet->bxsize, cursor_c, cursor_x, cursor_y, cursor_x + 7, cursor_y + 15);
}
sheet_refresh(sheet, cursor_x, cursor_y, cursor_x + 8, cursor_y + 16);
}
}
}
void HariMain(void)
{
struct BOOTINFO *binfo = (struct BOOTINFO *) ADR_BOOTINFO;
struct SHTCTL *shtctl;
char s[40];
struct FIFO32 fifo, keycmd;
int fifobuf[128], keycmd_buf[32];
int mx, my, i, new_mx = -1, new_my = 0, new_wx = 0x7fffffff, new_wy = 0;
unsigned int memtotal;
struct MOUSE_DEC mdec;
struct MEMMAN *memman = (struct MEMMAN *) MEMMAN_ADDR;
unsigned char *buf_back, buf_mouse[256];
struct SHEET *sht_back, *sht_mouse;
struct TASK *task_a, *task;
static char keytable0[0x80] = {
0, 0, '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '-', '^', 0x08, 0,
'Q', 'W', 'E', 'R', 'T', 'Y', 'U', 'I', 'O', 'P', '@', '[', 0x0a, 0, 'A', 'S',
'D', 'F', 'G', 'H', 'J', 'K', 'L', ';', ':', 0, 0, ']', 'Z', 'X', 'C', 'V',
'B', 'N', 'M', ',', '.', '/', 0, '*', 0, ' ', 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, '7', '8', '9', '-', '4', '5', '6', '+', '1',
'2', '3', '0', '.', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0x5c, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x5c, 0, 0
};
static char keytable1[0x80] = {
0, 0, '!', 0x22, '#', '$', '%', '&', 0x27, '(', ')', '~', '=', '~', 0x08, 0,
'Q', 'W', 'E', 'R', 'T', 'Y', 'U', 'I', 'O', 'P', '`', '{', 0x0a, 0, 'A', 'S',
'D', 'F', 'G', 'H', 'J', 'K', 'L', '+', '*', 0, 0, '}', 'Z', 'X', 'C', 'V',
'B', 'N', 'M', '<', '>', '?', 0, '*', 0, ' ', 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, '7', '8', '9', '-', '4', '5', '6', '+', '1',
'2', '3', '0', '.', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, '_', 0, 0, 0, 0, 0, 0, 0, 0, 0, '|', 0, 0
};
int key_shift = 0, key_leds = (binfo->leds >> 4) & 7, keycmd_wait = -1;
int j, x, y, mmx = -1, mmy = -1, mmx2 = 0;
struct SHEET *sht = 0, *key_win, *sht2;
int *fat;
unsigned char *nihongo;
struct FILEINFO *finfo;
extern char hankaku[4096];
init_gdtidt();
init_pic();
io_sti(); /* IDT/PICの初期化が終わったのでCPUの割り込み禁止を解除 */
fifo32_init(&fifo, 128, fifobuf, 0);
*((int *) 0x0fec) = (int) &fifo;
init_pit();
init_keyboard(&fifo, 256);
enable_mouse(&fifo, 512, &mdec);
io_out8(PIC0_IMR, 0xf8); /* PITとPIC1とキーボードを許可(11111000) */
io_out8(PIC1_IMR, 0xef); /* マウスを許可(11101111) */
fifo32_init(&keycmd, 32, keycmd_buf, 0);
memtotal = memtest(0x00400000, 0xbfffffff);
memman_init(memman);
memman_free(memman, 0x00001000, 0x0009e000); /* 0x00001000 - 0x0009efff */
memman_free(memman, 0x00400000, memtotal - 0x00400000);
init_palette();
shtctl = shtctl_init(memman, binfo->vram, binfo->scrnx, binfo->scrny);
task_a = task_init(memman);
fifo.task = task_a;
task_run(task_a, 1, 2);
*((int *) 0x0fe4) = (int) shtctl;
task_a->langmode = 0;
/* sht_back */
sht_back = sheet_alloc(shtctl);
buf_back = (unsigned char *) memman_alloc_4k(memman, binfo->scrnx * binfo->scrny);
sheet_setbuf(sht_back, buf_back, binfo->scrnx, binfo->scrny, -1); /* 透明色なし */
init_screen8(buf_back, binfo->scrnx, binfo->scrny);
/* sht_cons */
key_win = open_console(shtctl, memtotal);
/* sht_mouse */
sht_mouse = sheet_alloc(shtctl);
sheet_setbuf(sht_mouse, buf_mouse, 16, 16, 99);
init_mouse_cursor8(buf_mouse, 99);
mx = (binfo->scrnx - 16) / 2; /* 画面中央になるように座標計算 */
my = (binfo->scrny - 28 - 16) / 2;
sheet_slide(sht_back, 0, 0);
sheet_slide(key_win, 32, 4);
sheet_slide(sht_mouse, mx, my);
sheet_updown(sht_back, 0);
sheet_updown(key_win, 1);
sheet_updown(sht_mouse, 2);
keywin_on(key_win);
/* 最初にキーボード状態との食い違いがないように、設定しておくことにする */
fifo32_put(&keycmd, KEYCMD_LED);
fifo32_put(&keycmd, key_leds);
/* nihongo.fntの読み込み */
nihongo = (unsigned char *) memman_alloc_4k(memman, 16 * 256 + 32 * 94 * 47);
fat = (int *) memman_alloc_4k(memman, 4 * 2880);
file_readfat(fat, (unsigned char *) (ADR_DISKIMG + 0x000200));
finfo = file_search("nihongo.fnt", (struct FILEINFO *) (ADR_DISKIMG + 0x002600), 224);
if (finfo != 0) {
file_loadfile(finfo->clustno, finfo->size, nihongo, fat, (char *) (ADR_DISKIMG + 0x003e00));
} else {
for (i = 0; i < 16 * 256; i++) {
nihongo[i] = hankaku[i]; /* フォントがなかったので半角部分をコピー */
}
for (i = 16 * 256; i < 16 * 256 + 32 * 94 * 47; i++) {
nihongo[i] = 0xff; /* フォントがなかったので全角部分を0xffで埋め尽くす */
}
}
*((int *) 0x0fe8) = (int) nihongo;
memman_free_4k(memman, (int) fat, 4 * 2880);
for (;;) {
if (fifo32_status(&keycmd) > 0 && keycmd_wait < 0) {
/* キーボードコントローラに送るデータがあれば、送る */
keycmd_wait = fifo32_get(&keycmd);
wait_KBC_sendready();
io_out8(PORT_KEYDAT, keycmd_wait);
}
io_cli();
if (fifo32_status(&fifo) == 0) {
/* FIFOがからっぽになったので、保留している描画があれば実行する */
if (new_mx >= 0) {
io_sti();
sheet_slide(sht_mouse, new_mx, new_my);
new_mx = -1;
} else if (new_wx != 0x7fffffff) {
io_sti();
sheet_slide(sht, new_wx, new_wy);
new_wx = 0x7fffffff;
} else {
task_sleep(task_a);
io_sti();
}
} else {
i = fifo32_get(&fifo);
io_sti();
if (key_win != 0 && key_win->flags == 0) { /* ウィンドウが閉じられた */
if (shtctl->top == 1) { /* もうマウスと背景しかない */
key_win = 0;
} else {
key_win = shtctl->sheets[shtctl->top - 1];
keywin_on(key_win);
}
}
if (256 <= i && i <= 511) { /* キーボードデータ */
if (i < 0x80 + 256) { /* キーコードを文字コードに変換 */
if (key_shift == 0) {
s[0] = keytable0[i - 256];
} else {
s[0] = keytable1[i - 256];
}
} else {
s[0] = 0;
}
if ('A' <= s[0] && s[0] <= 'Z') { /* 入力文字がアルファベット */
if (((key_leds & 4) == 0 && key_shift == 0) ||
((key_leds & 4) != 0 && key_shift != 0)) {
s[0] += 0x20; /* 大文字を小文字に変換 */
}
}
if (s[0] != 0 && key_win != 0) { /* 通常文字、バックスペース、Enter */
fifo32_put(&key_win->task->fifo, s[0] + 256);
}
if (i == 256 + 0x0f && key_win != 0) { /* Tab */
keywin_off(key_win);
j = key_win->height - 1;
if (j == 0) {
j = shtctl->top - 1;
}
key_win = shtctl->sheets[j];
keywin_on(key_win);
}
if (i == 256 + 0x2a) { /* 左シフト ON */
key_shift |= 1;
}
if (i == 256 + 0x36) { /* 右シフト ON */
key_shift |= 2;
}
if (i == 256 + 0xaa) { /* 左シフト OFF */
key_shift &= ~1;
}
if (i == 256 + 0xb6) { /* 右シフト OFF */
key_shift &= ~2;
}
if (i == 256 + 0x3a) { /* CapsLock */
key_leds ^= 4;
fifo32_put(&keycmd, KEYCMD_LED);
fifo32_put(&keycmd, key_leds);
}
if (i == 256 + 0x45) { /* NumLock */
key_leds ^= 2;
fifo32_put(&keycmd, KEYCMD_LED);
fifo32_put(&keycmd, key_leds);
}
if (i == 256 + 0x46) { /* ScrollLock */
key_leds ^= 1;
fifo32_put(&keycmd, KEYCMD_LED);
fifo32_put(&keycmd, key_leds);
}
if (i == 256 + 0x3b && key_shift != 0 && key_win != 0) { /* Shift+F1 */
task = key_win->task;
if (task != 0 && task->tss.ss0 != 0) {
cons_putstr0(task->cons, "\nBreak(key) :\n");
io_cli(); /* 強制終了処理中にタスクが変わると困るから */
task->tss.eax = (int) &(task->tss.esp0);
task->tss.eip = (int) asm_end_app;
io_sti();
task_run(task, -1, 0); /* 終了処理を確実にやらせるために、寝ていたら起こす */
}
}
if (i == 256 + 0x3c && key_shift != 0) { /* Shift+F2 */
/* 新しく作ったコンソールを入力選択状態にする（そのほうが親切だよね？） */
if (key_win != 0) {
keywin_off(key_win);
}
key_win = open_console(shtctl, memtotal);
sheet_slide(key_win, 32, 4);
sheet_updown(key_win, shtctl->top);
keywin_on(key_win);
}
if (i == 256 + 0x57) { /* F11 */
sheet_updown(shtctl->sheets[1], shtctl->top - 1);
}
if (i == 256 + 0xfa) { /* キーボードがデータを無事に受け取った */
keycmd_wait = -1;
}
if (i == 256 + 0xfe) { /* キーボードがデータを無事に受け取れなかった */
wait_KBC_sendready();
io_out8(PORT_KEYDAT, keycmd_wait);
}
} else if (512 <= i && i <= 767) { /* マウスデータ */
if (mouse_decode(&mdec, i - 512) != 0) {
/* マウスカーソルの移動 */
mx += mdec.x;
my += mdec.y;
if (mx < 0) {
mx = 0;
}
if (my < 0) {
my = 0;
}
if (mx > binfo->scrnx - 1) {
mx = binfo->scrnx - 1;
}
if (my > binfo->scrny - 1) {
my = binfo->scrny - 1;
}
new_mx = mx;
new_my = my;
if ((mdec.btn & 0x01) != 0) {
/* 左ボタンを押している */
if (mmx < 0) {
/* 通常モードの場合 */
/* 上の下じきから順番にマウスが指している下じきを探す */
for (j = shtctl->top - 1; j > 0; j--) {
sht = shtctl->sheets[j];
x = mx - sht->vx0;
y = my - sht->vy0;
if (0 <= x && x < sht->bxsize && 0 <= y && y < sht->bysize) {
if (sht->buf[y * sht->bxsize + x] != sht->col_inv) {
sheet_updown(sht, shtctl->top - 1);
if (sht != key_win) {
keywin_off(key_win);
key_win = sht;
keywin_on(key_win);
}
if (3 <= x && x < sht->bxsize - 3 && 3 <= y && y < 21) {
mmx = mx; /* ウィンドウ移動モードへ */
mmy = my;
mmx2 = sht->vx0;
new_wy = sht->vy0;
}
if (sht->bxsize - 21 <= x && x < sht->bxsize - 5 && 5 <= y && y < 19) {
/* 「×」ボタンクリック */
if ((sht->flags & 0x10) != 0) { /* アプリが作ったウィンドウか？ */
task = sht->task;
cons_putstr0(task->cons, "\nBreak(mouse) :\n");
io_cli(); /* 強制終了処理中にタスクが変わると困るから */
task->tss.eax = (int) &(task->tss.esp0);
task->tss.eip = (int) asm_end_app;
io_sti();
task_run(task, -1, 0);
} else { /* コンソール */
task = sht->task;
sheet_updown(sht, -1); /* とりあえず非表示にしておく */
keywin_off(key_win);
key_win = shtctl->sheets[shtctl->top - 1];
keywin_on(key_win);
io_cli();
fifo32_put(&task->fifo, 4);
io_sti();
}
}
break;
}
}
}
} else {
/* ウィンドウ移動モードの場合 */
x = mx - mmx; /* マウスの移動量を計算 */
y = my - mmy;
new_wx = (mmx2 + x + 2) & ~3;
new_wy = new_wy + y;
mmy = my; /* 移動後の座標に更新 */
}
} else {
/* 左ボタンを押していない */
mmx = -1; /* 通常モードへ */
if (new_wx != 0x7fffffff) {
sheet_slide(sht, new_wx, new_wy); /* 一度確定させる */
new_wx = 0x7fffffff;
}
}
}
} else if (768 <= i && i <= 1023) { /* コンソール終了処理 */
close_console(shtctl->sheets0 + (i - 768));
} else if (1024 <= i && i <= 2023) {
close_constask(taskctl->tasks0 + (i - 1024));
} else if (2024 <= i && i <= 2279) { /* コンソールだけを閉じる */
sht2 = shtctl->sheets0 + (i - 2024);
memman_free_4k(memman, (int) sht2->buf, 256 * 165);
sheet_free(sht2);
}
}
}
}
void console_task(struct SHEET *sheet, unsigned int memtotal)
{
int fifobuf[128];
struct TASK *task = task_now();
struct TIMER *timer;
struct MEMMAN *memman = (struct MEMMAN *) MEMMAN_ADDR;
int *fat = (int *) memman_alloc_4k(memman, 4 * 2880);
struct CONSOLE cons = {sheet, 8, 28, -1};
int i;
char cmdline[30];
*((int *) 0x0fec) = (int) &cons;
fifo32_init(&task->fifo, 128, fifobuf, task);
timer = timer_alloc();
timer_init(timer, &task->fifo, 1);
timer_settime(timer, 50);
file_readfat(fat, (unsigned char *) (ADR_DISKIMG + 0x000200)); // 将FAT展开到fat中
/* 显示提示符 */
cons_putchar(&cons, '>', 1);
for (;;) {
io_cli();
if (fifo32_status(&task->fifo) == 0) {
task_sleep(task);
io_sti();
} else {
i = fifo32_get(&task->fifo);
io_sti();
if (i <= 1) { /* 光标用定时器 */
if (i != 0) {
timer_init(timer, &task->fifo, 0); /* 下次置0 */
if (cons.cur_c >= 0) {
cons.cur_c = COL8_FFFFFF;
}
} else {
timer_init(timer, &task->fifo, 1); /* 下次置1 */
if (cons.cur_c >= 0) {
cons.cur_c = COL8_000000;
}
}
timer_settime(timer, 50);
}
// 光标ON、OFF功能用于窗口切换时
if (i == 2) { /* 光标ON */
cons.cur_c = COL8_FFFFFF;
}
if (i == 3) { /* 光标OFF */
boxfill8(sheet->buf, sheet->bxsize, COL8_000000, cons.cur_x, cons.cur_y, cons.cur_x + 7, cons.cur_y + 15);
cons.cur_c = -1;
}
if (256 <= i && i <= 511) { /* 键盘数据（通过任务A） */
if (i == 8 + 256) {
/* 退格键 */
if (cons.cur_x > 16) {
/* 用空白擦除光标后将光标前移一位 */
cons_putchar(&cons, ' ', 0);
cons.cur_x -= 8;
}
} else if (i == 10 + 256) {
/* 回车键 */
/* 将光标用空格擦除后换行 */
cons_putchar(&cons, ' ', 0);
cmdline[cons.cur_x / 8 - 2] = 0;
cons_newline(&cons);
cons_runcmd(cmdline, &cons, fat, memtotal); /* 运行命令 */
/* 显示提示符 */
cons_putchar(&cons, '>', 1);
} else {
/* 一般字符 */
if (cons.cur_x < 240) {
/* 显示一个字符之后将光标后移一位 */
cmdline[cons.cur_x / 8 - 2] = i - 256;
cons_putchar(&cons, i - 256, 1);
}
}
}
/* 重新显示光标 */
if (cons.cur_c >= 0) {
boxfill8(sheet->buf, sheet->bxsize, cons.cur_c, cons.cur_x, cons.cur_y, cons.cur_x + 7, cons.cur_y + 15);
}
sheet_refresh(sheet, cons.cur_x, cons.cur_y, cons.cur_x + 8, cons.cur_y + 16);
}
}
}
void console_task(struct SHEET *sheet, int memtotal)
{
struct TASK *task = task_now();
struct MEMMAN *memman = (struct MEMMAN *) MEMMAN_ADDR;
int i, *fat = (int *) memman_alloc_4k(memman, 4 * 2880);
struct CONSOLE cons;
struct FILEHANDLE fhandle[8];
char cmdline[30];
unsigned char *nihongo = (char *) *((int *) 0x0fe8);
cons.sht = sheet;
cons.cur_x = 8;
cons.cur_y = 28;
cons.cur_c = -1;
task->cons = &cons;
task->cmdline = cmdline;
if (cons.sht != 0) {
cons.timer = timer_alloc();
timer_init(cons.timer, &task->fifo, 1);
timer_settime(cons.timer, 50);
}
file_readfat(fat, (unsigned char *) (ADR_DISKIMG + 0x000200));
for (i = 0; i < 8; i++) {
fhandle[i].buf = 0; /* �̻�� ��ũ */
}
task->fhandle = fhandle;
task->fat = fat;
if (nihongo[4096] != 0xff) { /* �Ϻ��� ��Ʈ ������ �о���� �� �־�����? */
task->langmode = 1;
} else {
task->langmode = 0;
}
task->langbyte1 = 0;
/* prompt ǥ�� */
cons_putchar(&cons, '>', 1);
for (;;) {
io_cli();
if (fifo32_status(&task->fifo) == 0) {
task_sleep(task);
io_sti();
} else {
i = fifo32_get(&task->fifo);
io_sti();
if (i <= 1 && cons.sht != 0) { /* Ŀ���� Ÿ�̸� */
if (i != 0) {
timer_init(cons.timer, &task->fifo, 0); /* ������ 0�� */
if (cons.cur_c >= 0) {
cons.cur_c = COL8_FFFFFF;
}
} else {
timer_init(cons.timer, &task->fifo, 1); /* ������ 1�� */
if (cons.cur_c >= 0) {
cons.cur_c = COL8_000000;
}
}
timer_settime(cons.timer, 50);
}
if (i == 2) { /* Ŀ�� ON */
cons.cur_c = COL8_FFFFFF;
}
if (i == 3) { /* Ŀ�� OFF */
if (cons.sht != 0) {
boxfill8(cons.sht->buf, cons.sht->bxsize, COL8_000000,
cons.cur_x, cons.cur_y, cons.cur_x + 7, cons.cur_y + 15);
}
cons.cur_c = -1;
}
if (i == 4) { /* �ܼ��� ��������ư Ŭ�� */
cmd_exit(&cons, fat);
}
if (256 <= i && i <= 511) { /* Ű���� ������(�½�ũ A����) */
if (i == 8 + 256) {
/* �� �����̽� */
if (cons.cur_x > 16) {
/* �����̽��� ����� ���� Ŀ���� 1�� back */
cons_putchar(&cons, ' ', 0);
cons.cur_x -= 8;
}
} else if (i == 10 + 256) {
/* Enter */
/* �����̽��� ����� ���� �����Ѵ� */
cons_putchar(&cons, ' ', 0);
cmdline[cons.cur_x / 8 - 2] = 0;
cons_newline(&cons);
cons_runcmd(cmdline, &cons, fat, memtotal); /* Ŀ�ǵ� ���� */
if (cons.sht == 0) {
cmd_exit(&cons, fat);
}
/* prompt ǥ�� */
cons_putchar(&cons, '>', 1);
} else {
/* �Ϲ� ���� */
if (cons.cur_x < 240) {
/* �� ���� ǥ���ϰ� ����, Ŀ���� 1�� �����Ѵ� */
cmdline[cons.cur_x / 8 - 2] = i - 256;
cons_putchar(&cons, i - 256, 1);
}
}
}
/* Ŀ����ǥ�� */
if (cons.sht != 0) {
if (cons.cur_c >= 0) {
boxfill8(cons.sht->buf, cons.sht->bxsize, cons.cur_c,
cons.cur_x, cons.cur_y, cons.cur_x + 7, cons.cur_y + 15);
}
sheet_refresh(cons.sht, cons.cur_x, cons.cur_y, cons.cur_x + 8, cons.cur_y + 16);
}
}
}
}
