void HariMain(void)
{
struct BOOTINFO *binfo = (struct BOOTINFO *) ADR_BOOTINFO;
char s[40], mcursor[256];
int mx, my;
init_gdtidt();
init_pic();
io_sti();
init_palette();
init_screen8(binfo->vram, binfo->scrnx, binfo->scrny);
mx = (binfo->scrnx - 16) / 2;
my = (binfo->scrny - 28 - 16) / 2;
init_mouse_cursor8(mcursor, COL8_008484);
putblock8_8(binfo->vram, binfo->scrnx, 16, 16, mx, my, mcursor, 16);
putfonts8_asc(binfo->vram, binfo->scrnx, 0, 0, COL8_FFFFFF, s);
io_out8(PIC0_IMR, 0xf9);
io_out8(PIC1_IMR, 0xef);
for (;;) {
io_hlt();
}
}
void
HariMain(void)
{
boot_info_t* binfo = (boot_info_t*)ADR_BOOTINFO;
char debug_info[64], mouse_cursor[256], keybuf[32];
int mouse_x, mouse_y;
init_gdt_idt();
init_pic();
io_sti();
fifo_init(&g_keybuf, keybuf, 32);
io_out8(PIC0_IMR, 0xf9);
io_out8(PIC1_IMR, 0xef);
init_keyboard(); /* initialize keyboard */
init_palette();
init_screen(binfo->vram, binfo->screen_x, binfo->screen_y);
mouse_x = (binfo->screen_x - 16) / 2;
mouse_y = (binfo->screen_y - 28 - 16) / 2;
init_mouse_cursor8(mouse_cursor, COLOR8_848484);
draw_block8_8(binfo->vram, binfo->screen_x, 16, 16,
mouse_x, mouse_y, mouse_cursor, 16);
draw_font8_asc(binfo->vram, binfo->screen_x, 8, 8,
COLOR8_FFFFFF, "HELLO BOYS:");
draw_font8_asc(binfo->vram, binfo->screen_x, 9, 9,
COLOR8_000000, "HELLO BOYS:");
draw_font8_asc(binfo->vram, binfo->screen_x, 31, 31,
COLOR8_000000, "WELCOME TO THE LOVELY TOY-OS.");
draw_font8_asc(binfo->vram, binfo->screen_x, 30, 30,
COLOR8_FFFFFF, "WELCOME TO THE LOVELY TOY-OS.");
sprintf(debug_info, "screen=>{%d, %d}", binfo->screen_x, binfo->screen_y);
draw_font8_asc(binfo->vram, binfo->screen_x, 16, 64,
COLOR8_FF0000, debug_info);
enable_mouse(); /* enabled mouse */
for ( ; ; ) {
int data;
io_cli();
if (0 == fifo_size(&g_keybuf))
io_stihlt();
else {
data = fifo_get(&g_keybuf);
io_sti();
sprintf(debug_info, "%02X", data);
fill_box8(binfo->vram, binfo->screen_x, COLOR8_008484, 0, 16, 15, 31);
draw_font8_asc(binfo->vram, binfo->screen_x,
0, 16, COLOR8_FFFFFF, debug_info);
}
}
}
int ldr_main(struct multiboot_info* boot_info, uint32 krnldr_size_bytes)
{
SetColor(MakeColor(DARK_BLUE, WHITE));
ClearScreen();
if (krnldr_size_bytes > 40 KB)
PANIC("Kernel Loader is too large");
init_kallocations(KRN_LDR_BASE + krnldr_size_bytes, KRN_LDR_LIMIT);
Print("Initializing descriptor tables.");
INT_OFF;
init_isr();
init_descriptor_tables();
init_pic();
INT_ON;
init_pit_timer(50, timer_callback);
struct kernel_info* k_info = kalloc(sizeof(struct kernel_info));
//setup AHCI
HBA_MEM_t* abar = PCIFindAHCI();
// initialize basic virtual memory
vmmngr_initialize();
uint32 ahci_base = kalloc_get_ptr() + 1024 - (uint32)kalloc_get_ptr() % 1024;
init_ahci(abar, ahci_base);
uint32 start, _length, position = 0;
fsysSimpleFind("MeOs.exe", 1, &_length, &start);
if (start == (uint32)-1 && _length == 0)
PANIC("Kernel module could not be found!");
while (position <= _length)
{
fsysSimpleRead(start + position / 512, 4096, KERNEL_BASE + position);
position += 4096;
}
// after all the loading is done... enable paging
vmmngr_paging_enable(true);
k_info->kernel_size = _length;
k_info->isr_handlers = interrupt_handlers;
k_info->gdt_base = gdt_entries;
k_info->idt_base = idt_entries;
printfln("Executing kernel\0");
execute_kernel(boot_info, k_info);
ClearScreen();
_asm cli
_asm hlt
}
void
HariMain(void)
{
boot_info_t* binfo = (boot_info_t*)ADR_BOOTINFO;
char debug_info[64], mouse_cursor[256];
int mouse_x, mouse_y;
init_gdt_idt();
init_pic();
io_sti();
io_out8(PIC0_IMR, 0xf9);
io_out8(PIC1_IMR, 0xef);
init_palette();
init_screen(binfo->vram, binfo->screen_x, binfo->screen_y);
mouse_x = (binfo->screen_x - 16) / 2;
mouse_y = (binfo->screen_y - 28 - 16) / 2;
init_mouse_cursor8(mouse_cursor, COLOR8_848484);
draw_block8_8(binfo->vram, binfo->screen_x, 16, 16,
mouse_x, mouse_y, mouse_cursor, 16);
draw_font8_asc(binfo->vram, binfo->screen_x, 8, 8,
COLOR8_FFFFFF, "HELLO BOYS:");
draw_font8_asc(binfo->vram, binfo->screen_x, 9, 9,
COLOR8_000000, "HELLO BOYS:");
draw_font8_asc(binfo->vram, binfo->screen_x, 31, 31,
COLOR8_000000, "WELCOME TO THE LOVELY TOY-OS.");
draw_font8_asc(binfo->vram, binfo->screen_x, 30, 30,
COLOR8_FFFFFF, "WELCOME TO THE LOVELY TOY-OS.");
sprintf(debug_info, "screen=>{%d, %d}", binfo->screen_x, binfo->screen_y);
draw_font8_asc(binfo->vram, binfo->screen_x, 16, 64,
COLOR8_FF0000, debug_info);
for ( ; ; ) {
int data, i;
io_cli();
if (0 == g_keybuf.next)
io_stihlt();
else {
data = g_keybuf.data[0];
--g_keybuf.next;
for (i = 0; i < g_keybuf.next; ++i)
g_keybuf.data[i] = g_keybuf.data[i + 1];
io_sti();
sprintf(debug_info, "%02X", data);
fill_box8(binfo->vram, binfo->screen_x, COLOR8_008484, 0, 16, 15, 31);
draw_font8_asc(binfo->vram, binfo->screen_x,
0, 16, COLOR8_FFFFFF, debug_info);
}
}
}
void main()
{
/* setup_adc_ports(AN0);
setup_adc(ADC_CLOCK_DIV_32);
setup_psp(PSP_DISABLED);
setup_spi(FALSE);
setup_counters( RTCC_INTERNAL, RTCC_DIV_1 | RTCC_8_BIT);
setup_timer_1(T1_DISABLED);
setup_timer_2(T2_DISABLED,0,1);
setup_comparator(NC_NC_NC_NC);
setup_vref(FALSE);
enable_interrupts(INT_RTCC);
enable_interrupts(INT_EXT);
enable_interrupts(GLOBAL);
EXT_INT_EDGE(L_TO_H);
OUTPUT_B(0);
OUTPUT_C(0);
SET_TRIS_B(0b00000111); //pins B0, B1 and B2 are set to give inputs. b0 is the external interuupt pin
SET_TRIS_C(0b00000000);
SET_TRIS_D(0b00000000);
set_adc_channel(0); */ //the next read_adc call will read channel 0
init_pic();
initialDisplay();
// OUTPUT_HIGH(PIN_C0);
// OUTPUT_LOW(PIN_C1);
OUTPUT_HIGH(PIN_C0);
OUTPUT_HIGH(PIN_C2);
OUTPUT_LOW(PIN_C3);
while(1)
{
phaseControl();
if(number_changed)
{
lcd_display(noOfPeople,14,1);
number_changed = 0;
}
if(counter_for_temp == 10000)
{
lcd_display_temperature();
counter_for_temp=0;
}
counter_for_temp++;
}
}
// Initialisation routine - zeroes all the interrupt service routines,
// initialises the GDT and IDT.
void init_descriptor_tables()
{
// Initialise the global descriptor table.
init_gdt();
// Initialise the interrupt descriptor table.
init_idt();
// Nullify all the interrupt handlers.
memset((u8int*)&interrupt_handlers, 0, sizeof(isr_t)*256);
//initial pic start interrupt
init_pic();
}
void init_idt()
{
idtp.limit = (sizeof (struct idt_entry) * 256) - 1;
idtp.base = (unsigned int) &idt;
memset(&idt, 0, sizeof(struct idt_entry) * 256);
init_pic();
init_isrs();
idt_load();
}
void HariMain(void)
{
struct BOOTINFO *binfo = (struct BOOTINFO *) ADR_BOOTINFO;
char s[40], mcursor[256], keybuf[32], mousebuf[128];
int mx, my, i;
init_gdtidt();
init_pic();
io_sti(); /* IDT/PIC的初始化结束，开启CPU中断 */
fifo8_init(&keyfifo, 32, keybuf);
fifo8_init(&mousefifo, 128, mousebuf);
io_out8(PIC0_IMR, 0xf9); /* 许可PIC1和键盘(11111001) */
io_out8(PIC1_IMR, 0xef); /* 许可鼠标(11101111) */
init_keyboard();
init_palette();
init_screen8(binfo->vram, binfo->scrnx, binfo->scrny);
mx = (binfo->scrnx - 16) / 2;
my = (binfo->scrny - 28 - 16) / 2;
init_mouse_cursor8(mcursor, COL8_008484);
putblock8_8(binfo->vram, binfo->scrnx, 16, 16, mx, my, mcursor, 16);
sprintf(s, "(%d, %d)", mx, my);
putfonts8_asc(binfo->vram, binfo->scrnx, 0, 0, COL8_FFFFFF, s);
enable_mouse();
for (;;) {
io_cli();
if (fifo8_status(&keyfifo) + fifo8_status(&mousefifo) == 0) {
/* J
char ss[10];
sprintf(ss, "%c", "J");
putfonts8_asc(binfo->vram, binfo->scrnx, 100, 100, COL8_FFFFFF, ss);
*/
io_stihlt();
} else if (fifo8_status(&keyfifo) != 0) {
i = fifo8_get(&keyfifo);
io_sti();
sprintf(s, "%02X", i);
boxfill8(binfo->vram, binfo->scrnx, COL8_008484, 0, 16, 15, 31);
putfonts8_asc(binfo->vram, binfo->scrnx, 0, 16, COL8_FFFFFF, s);
} else if (fifo8_status(&mousefifo) != 0) {
i = fifo8_get(&mousefifo);
io_sti();
sprintf(s, "%02X", i);
boxfill8(binfo->vram, binfo->scrnx, COL8_008484, 32, 16, 47, 31);
putfonts8_asc(binfo->vram, binfo->scrnx, 32, 16, COL8_FFFFFF, s);
}
}
}
void kernel_start()
{
init_pic();
init_gdt();
init_idt();
init_graphic();
io_sti();
while(1);
// halt();
}
void init_timer() {
t_counter = 0;
active_timer_count = 0;
int i;
//Clear the event timer table
for(i = 0; i < 10; i++)
event_timer[i].p = (process*)0;
init_pic();
init_time_chip(1000); //We use this initial low speed for MIPS calc //UPDATE: As of now, we're just doing it because we want a steady ~1ms timebase for timer functions
installInterrupt(TIMER_INT_NUM, &_handle_timerInt, 3);
installInterrupt(0xE7, &_spurious_handler, 3);
}
void setup_hw(void)
{
asm_cli();
puts("init gdt and idt\n");
init_gdtidt();
puts("init pic\n");
init_pic();
outb(PIC0_IMR, 0xf8); /* allow PIT, PIC1 and keyboard */
outb(PIC1_IMR, 0xef); /* allow mouse */
outb(0x20, 0x20);
asm_sti();
puts("init pit\n");
init_pit();
puts("setup hardware done\n");
}
void kernel_entry(uint32_t magic, MULTIBOOT_INFO *multiboot_info)
{
io_cli();
if(!init_memory(multiboot_info)){
//TODO: panic
}
init_gdtidt();
init_pit();
init_pic();
init_inthandler();
io_sti();
printf(TEXT_MODE_SCREEN_LEFT, "hello");
printf(TEXT_MODE_SCREEN_LEFT, "mem_lower: %d(KB)", multiboot_info->mem_lower);
printf(TEXT_MODE_SCREEN_LEFT, "mem_upper: %d(KB)", multiboot_info->mem_upper);
printf(TEXT_MODE_SCREEN_LEFT, "mem_total: %d(KB)", (multiboot_info->mem_upper + multiboot_info->mem_lower + 1024));
/* integer_puts(multiboot_info->mem_upper, 21); */
/* integer_puts(multiboot_info->mmap_addr, 22); */
/* integer_puts(multiboot_info->mmap_length, 23); */
/* list_test(); */
/* set_task(0, NULL, NULL); */
/* set_task(1, task1, stack[0]+1024); */
/* set_task(2, task2, stack[1]+1024); */
printf(TEXT_MODE_SCREEN_LEFT, "%x", &_kernel_end);
printf(TEXT_MODE_SCREEN_LEFT, "%x", &_kernel_start);
for(;;){
io_hlt();
/* * io_cli(); +| */
if (keyboard_data_queue_check()) {
/* io_sti(); */
}
else {
/* task_switch_c(0, 1); */
/* printf(TEXT_MODE_SCREEN_RIGHT, "test"); */
/* print_array_status(); */
}
}
}
void kernel_main()
{
/* Initialize terminal interface */
terminal_initialize();
init_idt();
init_pic();
init_keyboard();
/* Accept Intterupt now */
asm volatile("sti");
printf("VOID-OS Operating System 0.01\n\n");
printf("void-os$ ");
for(;;) {
asm("hlt");
}
}
void HariMain(void)
{
int i;
struct BOOTINFO *binfo = (struct BOOTINFO *)0x0ff0;
int xsize = (*binfo).scrnx;
int ysize = (*binfo).scrny;
char *vram = (*binfo).vram;
char msg[40], mcursor[256];
const int mx = xsize/2;
const int my = ysize/2;
init_gdtidt ();
init_pic ();
io_sti ();
init_pallete();
init_screen (vram, xsize, ysize);
putfonts8_asc (binfo->vram, binfo->scrnx, 8, 8, COL8_FFFFFF, "ABC 123");
putfonts8_asc (binfo->vram, binfo->scrnx, 31, 31, COL8_000000, "Haribote OS.");
putfonts8_asc (binfo->vram, binfo->scrnx, 30, 30, COL8_FFFFFF, "Haribote OS.");
sprintf(msg, "scrnx = %d", binfo->scrnx);
putfonts8_asc (binfo->vram, binfo->scrnx, 30, 48, COL8_FFFFFF, msg);
init_mouse_cursor8 (mcursor, COL8_008484);
putblock8_8 (binfo->vram, binfo->scrnx, 16, 16, mx,my, mcursor, 16);
io_out8(PIC0_IMR, 0xf9); /* PIC1とキーボードを許可(11111001) */
io_out8(PIC1_IMR, 0xef); /* マウスを許可(11101111) */
for (;;) {
io_cli();
if (keybuf.flag == 0) {
io_stihlt();
} else {
i = keybuf.data;
keybuf.flag = 0;
io_sti();
unsigned char s[4];
sprintf (s, "%x", i);
boxfill8(binfo->vram, binfo->scrnx, COL8_008484, 0, 48, 15, 31+48);
putfonts8_asc(binfo->vram, binfo->scrnx, 0, 48, COL8_FFFFFF, s);
}
}
}
void HariMain(void)
{
struct BOOTINFO *binfo = (struct BOOTINFO *) 0x0ff0;
char s[40], mcursor[256];
int mx, my, i;
init_gdtidt();
init_pic();
// Set IF (interrupt flag to 1)
io_sti();
init_palette();
init_screen8(binfo->vram, binfo->scrnx, binfo->scrny);
mx = (binfo->scrnx - 16) / 2; /* 画面中央になるように座標計算 */
my = (binfo->scrny - 28 - 16) / 2;
init_mouse_cursor8(mcursor, COL8_008484);
putblock8_8(binfo->vram, binfo->scrnx, 16, 16, mx, my, mcursor, 16);
sprintf(s, "(%d, %d)", mx, my);
putfonts8_asc(binfo->vram, binfo->scrnx, 0, 0, COL8_FFFFFF, s);
io_out8(PIC0_IMR, 0xf9); /* (11111001) Open IRQ 1 (keyboard) and IRQ 2 (connect to PIC 1) */
io_out8(PIC1_IMR, 0xef); /* (11101111) Open IRQ 12 */
//--keyboard
char keybuf[32];
fifo8_init(&keyfifo,32, keybuf);
init_keyboard();
for (;;)
{
io_cli();
if (fifo8_status(&keyfifo) == 0)
{
io_stihlt();
}
else
{
i = fifo8_get(&keyfifo);
io_sti();
sprintf(s, "%02X", i);
boxfill8(binfo->vram, binfo->scrnx, COL8_008484, 0, 16, 15, 31);
putfonts8_asc(binfo->vram, binfo->scrnx, 0, 16, COL8_FFFFFF, s);
}
}
}
int main()
{
/* const extern u32 _KERNEL_START[],_KERNEL_END[];
const extern u32 K_CODE_SEL[], K_DATA_SEL[];
const extern u32 _KERNEL_TEXT_START[],_KERNEL_TEXT_END[];
const extern u32 _KERNEL_DATA_START[],_KERNEL_DATA_END[];
const extern u32 _KERNEL_BSS_START[],_KERNEL_BSS_END[]; */
tty_cls();
banner();
/*if(TEST_BIT(K_MULTIBOOT_INFO->flags,MBI_FLAGS_MMAP)){
kprintf("MMAP Present: 0x%x\n",K_MULTIBOOT_INFO->mmap_addr);
memory_map_t *mmap;
for(mmap=(memory_map_t *)K_MULTIBOOT_INFO->mmap_addr;
(u32)mmap<K_MULTIBOOT_INFO->mmap_addr + K_MULTIBOOT_INFO->mmap_length;
mmap=(memory_map_t *)((u32)mmap+mmap->size+sizeof(mmap->size))){
kprintf("[%d] addr=0x%x-0x%x\n",mmap->type,mmap->base_addr_low,(mmap->base_addr_low+mmap->length_low));
}
}*/
kprintf(" > Initialising system services...\n");
init_interrupts();
init_paging();
init_heap();
set_cpu_caps();
init_pic();
init_timer();
init_process();
kprintf(" > Enabling kernel preemption...\n");
enable_kernel_preempt();
enable_ints();
kprintf(" > Spawning core process...\n");
create_process("core",NULL,&core);
/* We may get to here for a very short amount of time while we enable preemption */
while(1);
}
/** @brief Init OS after load.
* @param NULL
* @return NULL
*/
void OS_Init(void)
{
BOOTINFO* info;
int32 screenWidth, screenHeight;
uint8* bgBuf, *resVram;
boolean re[2];
uint32 tmpAddr;
InitPeripheralBuffer();
init_gdtidt();
init_pic();
io_sti(); // 恢复中断
tim_init();
io_out8(PIC0_IMR, 0xf8); /* PIT和PIC1和键盘设置为许可(11111000) */
io_out8(PIC1_IMR, 0xef); /* 鼠标设置为许可(11101111) */
info = (BOOTINFO*) ADR_BOOTINFO;
screenHeight = info->screenHeight;
screenWidth = info->screenWidth;
init_palette();
mem_init();
fat_init();
re[0] = mem_alloc(768 * 1024, &tmpAddr);
resVram = (uint8*)tmpAddr;
sheet_init(resVram);
InitMouse();
InitKeyboard();
re[1] = mem_alloc(768 * 1024, &tmpAddr);
bgBuf = (uint8*)tmpAddr;
//screenWidth * screenHeight
sheet_add(bgBuf, screenWidth, screenHeight, 0, 0, NONE_COL, &bgSheet);
fill_box(bgSheet, DARKGRASS, 0, 0, info->screenWidth, info->screenHeight);
if(re[0] == FALSE || re[1] == FALSE) {
fill_box(bgSheet, RED, 0, 0, info->screenWidth, info->screenHeight);
}
}
/* 0x1000 */
void _start(void)
{
clearscreen();
init_gdt();
print("Loading IDT\n");
init_idt();
print("Loading PIC\n");
init_pic();
print("Running kmain()\n");
sti;
kmain(); /* Call kernel's kmain() */
while (1)
{ /* Never return */
print("hlt;\n");
}
}
void HariMain(void)
{
struct BOOTINFO *binfo = (struct BOOTINFO *) ADR_BOOTINFO;
char s[40],mcursor[256], keybuf[32];
int mx, my, i;
init_gdtidt();
init_pic();
io_sti();
fifo8_init(&keyfifo, 32, keybuf);
io_out8(PIC0_IMR, 0xf9);
io_out8(PIC1_IMR, 0xef);
init_keyboard();
init_palette();
init_screen8(binfo->vram, binfo->scrnx, binfo->scrny);
mx = (binfo->scrnx - 16) / 2;
my = (binfo->scrny - 28 - 16) / 2;
init_mouse_cursor8(mcursor, COL8_008484);
putblock8_8(binfo->vram, binfo->scrnx, 16, 16, mx, my, mcursor, 16);
sprintf(s, "(%d, %d)", mx, my);
putfonts8_asc(binfo->vram, binfo->scrnx, 0, 0, COL8_FFFFFF, s);
enable_mouse();
for (;;) {
io_cli();
if(fifo8_status(&keyfifo) == 0){
io_stihlt();
} else{
i = fifo8_get(&keyfifo);
io_sti();
sprintf(s, "%02X", i);
boxfill8(binfo->vram, binfo->scrnx, COL8_008484, 0, 16, 15, 31);
putfonts8_asc(binfo->vram, binfo->scrnx, 0, 16, COL8_FFFFFF, s);
}
}
}
void HariMain(void)
{
int i;
struct BOOTINFO *binfo = (struct BOOTINFO *)0x0ff0;
int xsize = (*binfo).scrnx;
int ysize = (*binfo).scrny;
char *vram = (*binfo).vram;
init_gdtidt ();
init_pic ();
io_sti ();
init_pallete();
init_screen (vram, xsize, ysize);
putfont8_asc (binfo->vram, binfo->scrnx, 8, 8, COL8_FFFFFF, "ABC 123");
putfont8_asc (binfo->vram, binfo->scrnx, 31, 31, COL8_000000, "Haribote OS.");
putfont8_asc (binfo->vram, binfo->scrnx, 30, 30, COL8_FFFFFF, "Haribote OS.");
char msg[127];
sprintf(msg, "scrnx = %d", binfo->scrnx);
putfont8_asc (binfo->vram, binfo->scrnx, 30, 48, COL8_FFFFFF, msg);
char mcursor[16][16];
const int mx = xsize/2;
const int my = ysize/2;
init_mouse_cursor8 (mcursor, COL8_008484);
putblock8_8 (binfo->vram, binfo->scrnx, 16, 16, mx,my, mcursor, 16);
io_out8(PIC0_IMR, 0xf9); /* PIC1とキーボードを許可(11111001) */
io_out8(PIC1_IMR, 0xef); /* マウスを許可(11101111) */
for (;;) {
io_hlt();
}
}
// Point d' entrée du noyau
extern "C" void kmain(void) {
screen::print((char*) "kernel : kernel is speaking !\n");
idt_loader lidt;
lidt.init_idt();
screen::print((char*) "kernel : idt loaded\n");
init_pic();
screen::print((char*) "kernel : pic configured\n");
screen::print((char*) "kernel : loading new gdt...\n");
gdt_loader lgdt;
lgdt.init_gdt();
screen::print((char*)"kernel : gdt loaded\n");
asm(" movw $0x18, %ax \n \
movw %ax, %ss \n \
movl $0x20000, %esp");
main();
}
void HariMain(void)
{
struct BOOTINFO *binfo = (struct BOOTINFO *) ADR_BOOTINFO;
char s[40], mcursor[256];
int mx, my, i;
init_gdtidt();
init_pic();
io_sti(); /* IDT/PICの初期化が終わったのでCPUの割り込み禁止を解除 */
io_out8(PIC0_IMR, 0xf9); /* PIC1とキーボードを許可(11111001) */
io_out8(PIC1_IMR, 0xef); /* マウスを許可(11101111) */
init_palette();
init_screen8(binfo->vram, binfo->scrnx, binfo->scrny);
mx = (binfo->scrnx - 16) / 2; /* 画面中央になるように座標計算 */
my = (binfo->scrny - 28 - 16) / 2;
init_mouse_cursor8(mcursor, COL8_008484);
putblock8_8(binfo->vram, binfo->scrnx, 16, 16, mx, my, mcursor, 16);
sprintf(s, "(%d, %d)", mx, my);
putfonts8_asc(binfo->vram, binfo->scrnx, 0, 0, COL8_FFFFFF, s);
for (;;) {
io_cli();
if (keybuf.flag == 0) {
io_stihlt();
} else {
i = keybuf.data;
keybuf.flag = 0;
io_sti();
sprintf(s, "%02X", i);
boxfill8(binfo->vram, binfo->scrnx, COL8_008484, 0, 16, 15, 31);
putfonts8_asc(binfo->vram, binfo->scrnx, 0, 16, COL8_FFFFFF, s);
}
}
}
void setup_interrupt()
{
init_pic();
setup_interrupt_handler(idt, DEBUG);
setup_interrupt_handler(idt, NMI);
setup_interrupt_handler(idt, BREAKPOINT);
setup_interrupt_handler(idt, OVERFLOW);
setup_interrupt_handler(idt, BOUND_RANGE_EXCEDD);
setup_interrupt_handler(idt, INVALID_OP);
setup_interrupt_handler(idt, DEVICE_NOT_AVAL);
setup_interrupt_handler(idt, DOUBL_FAULT);
setup_interrupt_handler(idt, COP_SEGMENT);
setup_interrupt_handler(idt, IVALID_TSS);//这里修改了
setup_interrupt_handler(idt, SEGMENT_NOT_PRESETNT);
setup_interrupt_handler(idt, STACK_FAULT);
setup_interrupt_handler(idt, GENERAL_FAULT);
setup_interrupt_handler(idt, PAGE_FAULT);
setup_interrupt_handler(idt, TIMER);
/* set_up int used for usespace application */
set_idt(idt, INT_USER, HW_VC(48), DA_386TGate, 3);
load_idt();
local_irq_enable();
}
void HariMain(void)
{
char s[40];
struct MOUSE_DEC mdec;
int mx, my;
int i;
unsigned int memtotal;
unsigned int count;
fifo8 timerfifo;
char keybuf[KEYBUF_SIZE] = {0};
char mousebuf[MOUSEBUF_SIZE] = {0};
char timerbuf[8] = {0};
struct BOOTINFO *binfo;
struct MEMMAN *memman;
shtctl_t *shtctl;
sheet_t *sht_back, *sht_mouse, *sht_win;
unsigned char *buf_back, buf_mouse[256], *buf_win;
binfo = (struct BOOTINFO *) ADR_BOOTINFO;
memman = (struct MEMMAN *)MEMMAN_ADDR;
count = 0;
init_gdtidt ();
init_pic();
io_sti();
fifo8_init(&keyfifo, KEYBUF_SIZE, keybuf); /* keyboard */
fifo8_init(&mousefifo, MOUSEBUF_SIZE, mousebuf); /* mouse */
init_pit();
fifo8_init(&timerfifo, 8, timerbuf); /* timer */
settimer(100, &timerfifo, 1);
io_out8(PIC0_IMR, 0xf8); /* PIC1/keyboard/PIT设置为许可(11111000) */
io_out8(PIC1_IMR, 0xef); /* 鼠标设置为许可(11101111) */
init_keyboard ();
enable_mouse(&mdec);
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);
sht_back = sheet_alloc(shtctl);
sht_mouse = sheet_alloc(shtctl);
sht_win = sheet_alloc(shtctl);
buf_back = (unsigned char *) memman_alloc_4k(memman, binfo->scrnx * binfo->scrny);
buf_win = (unsigned char *) memman_alloc_4k(memman, 160 * 52);
sheet_setbuf(sht_back, buf_back, binfo->scrnx, binfo->scrny, -1);
sheet_setbuf(sht_mouse, buf_mouse, 16, 16, 99);
sheet_setbuf(sht_win, buf_win, 160, 52, -1);
init_screen8(buf_back, binfo->scrnx, binfo->scrny);
init_mouse_cursor8(buf_mouse, 99);
make_window8(buf_win, 160, 52, "counter");
sheet_slide(sht_back, 0, 0);
/* make it in the middle. */
mx = (binfo->scrnx - 16) / 2;
my = (binfo->scrny - 28 - 16) / 2;
//init_mouse_cursor8(mcursor, COL8_008484);
sheet_slide(sht_mouse, mx, my);
sheet_slide(sht_win, 80, 72);
sheet_updown(sht_back, 0);
sheet_updown(sht_win, 1);
sheet_updown(sht_mouse, 2);
//putblock8_8(binfo->vram, binfo->scrnx, 16, 16, mx, my, mcursor, 16);
sprintf(s, "(%3d, %3d)", mx, my);
putfonts8_asc(buf_back, binfo->scrnx, 0, 0, COL8_FFFFFF, s);
sprintf(s, "memory %dMB free : %dKB",
memtotal / (1024 * 1024), memman_total(memman) / 1024);
putfonts8_asc(buf_back, binfo->scrnx, 0, 32, COL8_FFFFFF, s);
sheet_refresh(sht_back, 0, 0, binfo->scrnx, 48);
for (;;) {
++count;
sprintf(s, "%u, %u", timerctl.count, timerctl.timeout);
boxfill8(buf_win, 160, COL8_C6C6C6, 40, 28, 119, 43);
putfonts8_asc(buf_win, 160, 40, 28, COL8_000000, s);
sheet_refresh(sht_win, 40, 28, 120, 44);
io_cli();
if (fifo8_status(&keyfifo) + fifo8_status(&mousefifo) + fifo8_status(&timerfifo) == 0){
io_sti();
} else {
if (fifo8_status(&keyfifo) != 0) {
i = fifo8_get(&keyfifo);
io_sti();
sprintf(s, "%02X", i);
boxfill8(buf_back, binfo->scrnx, COL8_008484, 0, 16, 15, 31);
putfonts8_asc(buf_back, binfo->scrnx, 0, 16, COL8_FFFFFF, s);
sheet_refresh(sht_back, 0, 16, 16, 32);
} else if (fifo8_status(&mousefifo) != 0){
i = fifo8_get(&mousefifo);
io_sti();
if (mouse_decode(&mdec, i) != 0) {
sprintf(s, "[lcr %4d %4d]", mdec.x, mdec.y);
if ((mdec.btn & 0x01) != 0)
s[1] = 'L';
if ((mdec.btn & 0x02) != 0)
s[3] = 'R';
if ((mdec.btn & 0x04) != 0)
s[2] = 'C';
boxfill8(buf_back, binfo->scrnx, COL8_008484, 32, 16, 32 + 15 * 8 - 1, 31);
putfonts8_asc(buf_back, binfo->scrnx, 32, 16, COL8_FFFFFF, s);
sheet_refresh(sht_back, 32, 16, 32 + 15 * 8, 32);
/* 鼠标指针的移动 */
//boxfill8(binfo->vram, binfo->scrnx, COL8_008484, mx, my, mx + 15, my + 15); /* 隐藏鼠标 */
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;
sprintf(s, "(%3d, %3d)", mx, my);
boxfill8(buf_back, binfo->scrnx, COL8_008484, 0, 0, 79, 15); /* 隐藏坐标 */
putfonts8_asc(buf_back, binfo->scrnx, 0, 0, COL8_FFFFFF, s); /* 显示坐标 */
sheet_refresh(sht_back, 0, 0, 80, 16);
sheet_slide(sht_mouse, mx, my);
//putblock8_8(binfo->vram, binfo->scrnx, 16, 16, mx, my, mcursor, 16); /* 描画鼠标 */
}
} else if (fifo8_status(&timerfifo) != 0) {
i = fifo8_get(&timerfifo);
io_sti();
putfonts8_asc(buf_back, binfo->scrnx, 0, 64, COL8_FFFFFF, "10[sec]");
sheet_refresh(sht_back, 0, 64, 56, 80);
}
}
}
}
void HariMain(void)
{
struct BOOTINFO *binfo = (struct BOOTINFO *) 0x0ff0;//the boot info saved in asmhead
char s[40];
int mx, my, i, cursor_x, cursor_c;
unsigned int memtotal;
struct MOUSE_DEC mdec;
//内存管理结构地址
struct MEMMAN *memman = (struct MEMMAN *) MEMMAN_ADDR;
struct SHTCTL *shtctl;
static char keytable0[0x80] = {
0, 0, '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '-', '^', 0, 0,
'Q', 'W', 'E', 'R', 'T', 'Y', 'U', 'I', 'O', 'P', '@', '[', 0, 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, 0,
'Q', 'W', 'E', 'R', 'T', 'Y', 'U', 'I', 'O', 'P', '`', '{', 0, 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
};
unsigned char *buf_back, buf_mouse[256], *buf_win, *buf_win_b, *buf_cons;
struct SHEET *sht_back, *sht_mouse, *sht_win, *sht_win_b[3], *sht_cons;
struct TASK *task_a, *task_b[3], *task_cons;
struct TIMER *timer;
int key_to = 0, key_shift = 0, key_leds = (binfo->leds >> 4) & 7, keycmd_wait = -1;
struct FIFO32 fifo, keycmd;
int fifobuf[128], keycmd_buf[32];
init_gdtidt();
init_pic();//init the programed interrupt controller.
io_sti(); // enable interrupt
fifo32_init(&fifo, 128, fifobuf, 0);//初始化队列
init_pit();//初始化计时器;
init_keyboard(&fifo, 256);
enable_mouse(&fifo, 512, &mdec);//鼠标中断
io_out8(PIC0_IMR, 0xf8); /* PIC1 允许 0(timer),1,2号中断，屏蔽其他(11111000) */
io_out8(PIC1_IMR, 0xef); /* 允许c号中断，屏蔽其他(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,0);
*((int *) 0x0fe4) = (int) shtctl;
/* 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 */
sht_cons = sheet_alloc(shtctl);
buf_cons = (unsigned char *) memman_alloc_4k(memman, 256 * 165);
sheet_setbuf(sht_cons, buf_cons, 256, 165, -1); /* 摟柧怓側偟 */
make_window8(buf_cons, 256, 165, "console", 0);
make_textbox8(sht_cons, 8, 28, 240, 128, COL8_000000);
task_cons = task_alloc();
task_cons->tss.esp = memman_alloc_4k(memman, 64 * 1024) + 64 * 1024 - 12;
task_cons->tss.eip = (int) &console_task;
task_cons->tss.es = 1 * 8;
task_cons->tss.cs = 2 * 8;
task_cons->tss.ss = 1 * 8;
task_cons->tss.ds = 1 * 8;
task_cons->tss.fs = 1 * 8;
task_cons->tss.gs = 1 * 8;
*((int *) (task_cons->tss.esp + 4)) = (int) sht_cons;
*((int *) (task_cons->tss.esp + 8)) = memtotal;
task_run(task_cons, 2, 2); /* level=2, priority=2 */
/* 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;
/* sht_win_b */
for (i = 0; i < 3; i++) {
sht_win_b[i] = sheet_alloc(shtctl);
buf_win_b = (unsigned char *) memman_alloc_4k(memman, 144 * 52);
sheet_setbuf(sht_win_b[i], buf_win_b, 144, 52, -1); /* 无透明 */
sprintf(s, "task_b%d", i);
make_window8(buf_win_b, 144, 52, s, 0);
task_b[i] = task_alloc();
task_b[i]->tss.esp = memman_alloc_4k(memman, 64 * 1024) + 64 * 1024 - 8;
task_b[i]->tss.eip = (int) &task_b_main;
task_b[i]->tss.es = 1 * 8;
task_b[i]->tss.cs = 2 * 8;
task_b[i]->tss.ss = 1 * 8;
task_b[i]->tss.ds = 1 * 8;
task_b[i]->tss.fs = 1 * 8;
task_b[i]->tss.gs = 1 * 8;
*((int *) (task_b[i]->tss.esp + 4)) = (int) sht_win_b[i];
//task_run(task_b[i],2,i+1);
}
/* sht_win */
sht_win = sheet_alloc(shtctl);
buf_win = (unsigned char *) memman_alloc_4k(memman, 160 * 52);
sheet_setbuf(sht_win, buf_win, 144, 52, -1); /* 摟柧怓側偟 */
make_window8(buf_win, 144, 52, "task_a", 1);
make_textbox8(sht_win, 8, 28, 128, 16, COL8_FFFFFF);
cursor_x = 8;
cursor_c = COL8_FFFFFF;//白色
timer = timer_alloc();
timer_init(timer, &fifo, 1);
timer_settime(timer, 50);
sheet_slide(sht_back, 0, 0);
sheet_slide(sht_win_b[0], 168, 56);
sheet_slide(sht_win_b[1], 8, 116);
sheet_slide(sht_win_b[2], 168, 116);
sheet_slide(sht_win, 8, 56);
sheet_slide(sht_mouse, mx, my);
sheet_slide(sht_cons, 32, 4);
/*设置图层高度，并显示*/
sheet_slide(sht_back, 0, 0);
sheet_slide(sht_cons, 32, 4);
sheet_slide(sht_win, 64, 56);
sheet_slide(sht_mouse, mx, my);
sheet_updown(sht_back, 0);
sheet_updown(sht_cons, 1);
sheet_updown(sht_win, 2);
sheet_updown(sht_mouse, 3);
//键盘指示灯
fifo32_put(&keycmd, KEYCMD_LED);
fifo32_put(&keycmd, key_leds);
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) {
task_sleep(task_a);
io_sti();
}
else{
i = fifo32_get(&fifo);
io_sti();
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) { /* 一般字符 */
if (key_to == 0) { /* 发送给任务A */
if (cursor_x < 128) {
s[1] = 0;
putfonts8_asc_sht(sht_win, cursor_x, 28, COL8_000000, COL8_FFFFFF, s, 1);
cursor_x += 8;
}
} else { /* 发送给命令行窗口 */
fifo32_put(&task_cons->fifo, s[0] + 256);
}
}
if (i == 256 + 0x0e) { /* 退格键 */
if (key_to == 0) { /* 发送给任务A */
if (cursor_x > 8) {
/* 用白色擦出光标后将光标前移移位*/
putfonts8_asc_sht(sht_win, cursor_x, 28, COL8_000000, COL8_FFFFFF, " ", 1);
cursor_x -= 8;
}
} else { /* 发送给命令窗口 */
fifo32_put(&task_cons->fifo, 8 + 256);
}
}
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 + 0x0f) { /* Tab */
if (key_to == 0) {
key_to = 1;
make_wtitle8(buf_win, sht_win->bxsize, "task_a", 0);
make_wtitle8(buf_cons, sht_cons->bxsize, "console", 1);
cursor_c = -1; /* 不显示光标 */
boxfill8(sht_win->buf, sht_win->bxsize, COL8_FFFFFF, cursor_x, 28, cursor_x + 7, 43);
fifo32_put(&task_cons->fifo, 2); /* 令命令行窗口光标ON */
} else {
key_to = 0;
make_wtitle8(buf_win, sht_win->bxsize, "task_a", 1);
make_wtitle8(buf_cons, sht_cons->bxsize, "console", 0);
cursor_c = COL8_000000; /* 显示光标 */
fifo32_put(&task_cons->fifo, 3); /* 令命令行窗口光标OFF */
}
sheet_refresh(sht_win, 0, 0, sht_win->bxsize, 21);
sheet_refresh(sht_cons, 0, 0, sht_cons->bxsize, 21);
}
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 + 0xfa) { /* 键盘成功接收 */
keycmd_wait = -1;
}
if (i == 256 + 0xfe) { /* 键盘没有成功接收到数据 */
wait_KBC_sendready();
io_out8(PORT_KEYDAT, keycmd_wait);
}
if (i == 256 + 0x1c) { /* Enter */
if (key_to != 0) { /* 发送命令给窗口 */
fifo32_put(&task_cons->fifo, 10 + 256);
}
}
//重新显示光标
if (cursor_c >= 0) {
boxfill8(sht_win->buf, sht_win->bxsize, cursor_c, cursor_x, 28, cursor_x + 7, 43);
}
sheet_refresh(sht_win, cursor_x, 28, cursor_x + 8, 44);
} 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;
}
sheet_slide(sht_mouse, mx, my);
if ((mdec.btn & 0x01) != 0) {
/* 始终定位鼠标的左上角 */
sheet_slide(sht_win, mx - 80, my - 8);
}
}
}else if (i <= 1) { /* 光标定时器 */
if (i != 0) {
timer_init(timer, &fifo, 0); /* 下次置0 */
if (cursor_c >= 0) {
cursor_c = COL8_000000;
}
} else {
timer_init(timer, &fifo, 1); /* 下次置1 */
if (cursor_c >= 0) {
cursor_c = COL8_FFFFFF;
}
}
timer_settime(timer, 50);
if (cursor_c >= 0) {
boxfill8(sht_win->buf, sht_win->bxsize, cursor_c, cursor_x, 28, cursor_x + 7, 43);
sheet_refresh(sht_win, cursor_x, 28, cursor_x + 8, 44);
}
}
}
}
}
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, cursor_x, cursor_c;
unsigned int memtotal;
struct MOUSE_DEC mdec;
struct MEMMAN *memman = (struct MEMMAN *) MEMMAN_ADDR;
unsigned char *buf_back, buf_mouse[256], *buf_win, *buf_cons;
struct SHEET *sht_back, *sht_mouse, *sht_win, *sht_cons;
struct TASK *task_a, *task_cons;
struct TIMER *timer;
static char keytable0[0x80] = {
0, 0, '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '-', '^', 0, 0,
'Q', 'W', 'E', 'R', 'T', 'Y', 'U', 'I', 'O', 'P', '@', '[', 0, 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, 0,
'Q', 'W', 'E', 'R', 'T', 'Y', 'U', 'I', 'O', 'P', '`', '{', 0, 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_to = 0, key_shift = 0, key_leds = (binfo->leds >> 4) & 7, keycmd_wait = -1;
struct CONSOLE *cons;
init_gdtidt();
init_pic();
io_sti(); /* IDT/PICの初期化が終わったのでCPUの割り込み禁止を解除 */
fifo32_init(&fifo, 128, fifobuf, 0);
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;
/* 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 */
sht_cons = sheet_alloc(shtctl);
buf_cons = (unsigned char *) memman_alloc_4k(memman, 256 * 165);
sheet_setbuf(sht_cons, buf_cons, 256, 165, -1); /* 透明色なし */
make_window8(buf_cons, 256, 165, "console", 0);
make_textbox8(sht_cons, 8, 28, 240, 128, COL8_000000);
task_cons = task_alloc();
task_cons->tss.esp = memman_alloc_4k(memman, 64 * 1024) + 64 * 1024 - 12;
task_cons->tss.eip = (int) &console_task;
task_cons->tss.es = 1 * 8;
task_cons->tss.cs = 2 * 8;
task_cons->tss.ss = 1 * 8;
task_cons->tss.ds = 1 * 8;
task_cons->tss.fs = 1 * 8;
task_cons->tss.gs = 1 * 8;
*((int *) (task_cons->tss.esp + 4)) = (int) sht_cons;
*((int *) (task_cons->tss.esp + 8)) = memtotal;
task_run(task_cons, 2, 2); /* level=2, priority=2 */
/* sht_win */
sht_win = sheet_alloc(shtctl);
buf_win = (unsigned char *) memman_alloc_4k(memman, 160 * 52);
sheet_setbuf(sht_win, buf_win, 144, 52, -1); /* 透明色なし */
make_window8(buf_win, 144, 52, "task_a", 1);
make_textbox8(sht_win, 8, 28, 128, 16, COL8_FFFFFF);
cursor_x = 8;
cursor_c = COL8_FFFFFF;
timer = timer_alloc();
timer_init(timer, &fifo, 1);
timer_settime(timer, 50);
/* 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(sht_cons, 32, 4);
sheet_slide(sht_win, 64, 56);
sheet_slide(sht_mouse, mx, my);
sheet_updown(sht_back, 0);
sheet_updown(sht_cons, 1);
sheet_updown(sht_win, 2);
sheet_updown(sht_mouse, 3);
/* 最初にキーボード状態との食い違いがないように、設定しておくことにする */
fifo32_put(&keycmd, KEYCMD_LED);
fifo32_put(&keycmd, key_leds);
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) {
task_sleep(task_a);
io_sti();
} else {
i = fifo32_get(&fifo);
io_sti();
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) { /* 通常文字 */
if (key_to == 0) { /* タスクAへ */
if (cursor_x < 128) {
/* 一文字表示してから、カーソルを1つ進める */
s[1] = 0;
putfonts8_asc_sht(sht_win, cursor_x, 28, COL8_000000, COL8_FFFFFF, s, 1);
cursor_x += 8;
}
} else { /* コンソールへ */
fifo32_put(&task_cons->fifo, s[0] + 256);
}
}
if (i == 256 + 0x0e) { /* バックスペース */
if (key_to == 0) { /* タスクAへ */
if (cursor_x > 8) {
/* カーソルをスペースで消してから、カーソルを1つ戻す */
putfonts8_asc_sht(sht_win, cursor_x, 28, COL8_000000, COL8_FFFFFF, " ", 1);
cursor_x -= 8;
}
} else { /* コンソールへ */
fifo32_put(&task_cons->fifo, 8 + 256);
}
}
if (i == 256 + 0x1c) { /* Enter */
if (key_to != 0) { /* コンソールへ */
fifo32_put(&task_cons->fifo, 10 + 256);
}
}
if (i == 256 + 0x0f) { /* Tab */
if (key_to == 0) {
key_to = 1;
make_wtitle8(buf_win, sht_win->bxsize, "task_a", 0);
make_wtitle8(buf_cons, sht_cons->bxsize, "console", 1);
cursor_c = -1; /* カーソルを消す */
boxfill8(sht_win->buf, sht_win->bxsize, COL8_FFFFFF, cursor_x, 28, cursor_x + 7, 43);
fifo32_put(&task_cons->fifo, 2); /* コンソールのカーソルON */
} else {
key_to = 0;
make_wtitle8(buf_win, sht_win->bxsize, "task_a", 1);
make_wtitle8(buf_cons, sht_cons->bxsize, "console", 0);
cursor_c = COL8_000000; /* カーソルを出す */
fifo32_put(&task_cons->fifo, 3); /* コンソールのカーソルOFF */
}
sheet_refresh(sht_win, 0, 0, sht_win->bxsize, 21);
sheet_refresh(sht_cons, 0, 0, sht_cons->bxsize, 21);
}
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 && task_cons->tss.ss0 != 0) { /* Shift+F1 */
cons = (struct CONSOLE *) *((int *) 0x0fec);
cons_putstr0(cons, "\nBreak(key) :\n");
io_cli(); /* 強制終了処理中にタスクが変わると困るから */
task_cons->tss.eax = (int) &(task_cons->tss.esp0);
task_cons->tss.eip = (int) asm_end_app;
io_sti();
}
if (i == 256 + 0x57 && shtctl->top > 2) { /* 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);
}
/* カーソルの再表示 */
if (cursor_c >= 0) {
boxfill8(sht_win->buf, sht_win->bxsize, cursor_c, cursor_x, 28, cursor_x + 7, 43);
}
sheet_refresh(sht_win, cursor_x, 28, cursor_x + 8, 44);
} 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;
}
sheet_slide(sht_mouse, mx, my);
if ((mdec.btn & 0x01) != 0) {
/* 左ボタンを押していたら、sht_winを動かす */
sheet_slide(sht_win, mx - 80, my - 8);
}
}
} else if (i <= 1) { /* カーソル用タイマ */
if (i != 0) {
timer_init(timer, &fifo, 0); /* 次は0を */
if (cursor_c >= 0) {
cursor_c = COL8_000000;
}
} else {
timer_init(timer, &fifo, 1); /* 次は1を */
if (cursor_c >= 0) {
cursor_c = COL8_FFFFFF;
}
}
timer_settime(timer, 50);
if (cursor_c >= 0) {
boxfill8(sht_win->buf, sht_win->bxsize, cursor_c, cursor_x, 28, cursor_x + 7, 43);
sheet_refresh(sht_win, cursor_x, 28, cursor_x + 8, 44);
}
}
}
}
}
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_console[2], *task; //后面的那个task只是作为一个临时变量来用的
CONSOLE *console;
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 = 0, new_mcursorY = 0, new_layerX = 0x7fffffff, new_layerY = 0;
LAYER *layer = 0, *key_to_window; //key_to_window这个变量记录当前的键盘输入到哪个窗口中
unsigned int memory_total, i;
char buf_cursor[mCursorWidth * mCursorHeight];
unsigned char *buf_bg, *buf_console[2]; //屏幕的大背景会在init_screen的时候画出来，这里只需要一个指向它的指针即可
unsigned char strings[40];
mCursorX = binfo->scrnx / 2;
mCursorY = (binfo->scrny - 28)/ 2; //减去下方任务栏的高度
/*内存检查*/
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_fifo(&keycmd_fifo, 32, keycmd_buf, 0);
/*初始化接收中断的缓冲区*/
init_fifo(&fifo_mutual, 128, fifobuf, 0); //初始化mouseFIFO缓冲区，现在还没任务，先指定为0
/*初始化GDT和IDT表以及PIC板的数据*/
init_GDTandIDT(); //初始化GDT和IDT表
init_pic(); //初始化PIC主从板数据，除了IRQ2禁止了全部中断
io_sti(); //开始接收中断
/*初始化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)， 开放鼠标中断
/*初始化任务切换管理*/
task_a = task_init(memmanage); //这个task_a其实代表的就是这些鼠标键盘等的任务
fifo_mutual.task = task_a; //为鼠标键盘等的缓冲区指定唤醒任务为task_a
task_run(task_a, 1, 2);
/*初始化调色板，为图形界面做准备*/
init_palette(); //初始化调色板
/*初始化图层管理，并且初始化鼠标光标和背景的图层*/
layer_manage = layer_man_init(memmanage, binfo->vram, binfo->scrnx, binfo->scrny);
*((int *) 0x0fe4) = (int) layer_manage;
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函数了，直接用这个图层管理的绘图函数就行
/*执行两个命令行窗口任务*/
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);
}
}
//如果是键盘中断的话，需要处理键盘发送来的中断数据
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
if(strings[0] != 0 && key_to_window != 0)
{
fifo_put(&key_to_window->task->fifo, strings[0] + 256);
}
//如果按下了ctrl+d，就打开一个console
if(('D' == strings[0] || 'd' == strings[0]) && (0 != key_ctrl))
{
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);
}
//如果同时按下了ctrl+x，那么就关闭应用程序
if(('X' == strings[0] || 'x' == strings[0]) && (0 != key_ctrl) && key_to_window != 0)
{
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();
}
}
/*这些都是那些不能打印的特殊按键，它们对应的都是0*/
//按下“TAB键”的处理情况，切换输入窗口
if(i == keyboard_offset + 0x0f && key_to_window != 0)
{
//先让当前的窗口的光标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);
}
//键盘成功接收到数据
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();
}
//不是应用程序的话就是console命令行窗口产生的layer
else
{
//不能再这里的task_a中直接关闭，因为还有些console自身管理的定时器和fat等东西无法释放了
task = layer->task;
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));
}
}
}
}
void HariMain(void)
{
struct BOOTINFO *binfo = (struct BOOTINFO *) ADR_BOOTINFO;
struct FIFO32 fifo;
char s[40];
int fifobuf[128];
struct TIMER *timer, *timer2, *timer3;
int mx, my, i, cursor_x, cursor_c; // cursor_x: 记录光标显示位置
unsigned int memtotal;
struct MOUSE_DEC mdec;
struct MEMMAN *memman = (struct MEMMAN *) MEMMAN_ADDR;
struct SHTCTL *shtctl;
struct SHEET *sht_back, *sht_mouse, *sht_win;
unsigned char *buf_back, buf_mouse[256], *buf_win;
static char keytable[0x54] = {
0, 0, '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '-', '=', 0, 0,
'Q', 'W', 'E', 'R', 'T', 'Y', 'U', 'I', 'O', 'P', '[', ']', 0, 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', '.'
};
init_gdtidt();
init_pic();
io_sti(); /* IDT/PIC的初始化结束，开启CPU中断 */
fifo32_init(&fifo, 128, fifobuf);
init_pit();
init_keyboard(&fifo, 256);
enable_mouse(&fifo, 512, &mdec);
io_out8(PIC0_IMR, 0xf8); /* 许可PIC1和键盘(11111000) */
io_out8(PIC1_IMR, 0xef); /* 许可鼠标(11101111) */
timer = timer_alloc();
timer_init(timer, &fifo, 10);
timer_settime(timer, 1000);
timer2 = timer_alloc();
timer_init(timer2, &fifo, 3);
timer_settime(timer2, 300);
timer3 = timer_alloc();
timer_init(timer3, &fifo, 1);
timer_settime(timer3, 50);
memtotal = memtest(0x00400000, 0xbfffffff); // 使用的内存空间，包含了0x00400000前已用的内存
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);
sht_back = sheet_alloc(shtctl);
sht_mouse = sheet_alloc(shtctl);
sht_win = sheet_alloc(shtctl);
buf_back = (unsigned char *) memman_alloc_4k(memman, binfo->scrnx * binfo->scrny);
buf_win = (unsigned char *) memman_alloc_4k(memman, 160 * 52);
sheet_setbuf(sht_back, buf_back, binfo->scrnx, binfo->scrny, -1); /* 没有透明色 */
sheet_setbuf(sht_mouse, buf_mouse, 16, 16, 99); // 透明色号99
sheet_setbuf(sht_win, buf_win, 160, 52, -1); /* 没有透明色 */
init_screen8(buf_back, binfo->scrnx, binfo->scrny);
init_mouse_cursor8(buf_mouse, 99);
make_window8(buf_win, 160, 52, "window");
make_textbox8(sht_win, 8, 28, 144, 16, COL8_FFFFFF);
cursor_x = 8;
cursor_c = COL8_FFFFFF;
sheet_slide(sht_back, 0, 0);
mx = (binfo->scrnx - 16) / 2;
my = (binfo->scrny - 28 - 16) / 2;
sheet_slide(sht_mouse, mx, my);
sheet_slide(sht_win, 80, 72);
sheet_updown(sht_back, 0);
sheet_updown(sht_win, 1);
sheet_updown(sht_mouse, 2);
sprintf(s, "(%3d, %3d)", mx, my);
putfonts8_asc_sht(sht_back, 0, 0, COL8_FFFFFF, COL8_008484, s, 10);
sprintf(s, "memory %dMB free : %dKB", memtotal / (1024 * 1024), memman_total(memman) / 1024);
putfonts8_asc_sht(sht_back, 0, 32, COL8_FFFFFF, COL8_008484, s, 40);
for (;;) {
io_cli();
if (fifo32_status(&fifo) == 0) {
/* J
char ss[10];
sprintf(ss, "%c", "J");
putfonts8_asc(binfo->vram, binfo->scrnx, 100, 100, COL8_FFFFFF, ss);
*/
io_stihlt();
} else {
i = fifo32_get(&fifo);
io_sti();
if (256 <= i && i <= 511) { /* 键盘数据 */
sprintf(s, "%02X", i - 256);
putfonts8_asc_sht(sht_back, 0, 16, COL8_FFFFFF, COL8_008484, s, 2);
if (i < 256 + 0x54) {
if (keytable[i - 256] != 0 && cursor_x < 144) { /* 通常文字 */
/* 显示1个字符就前移1次光标 */
s[0] = keytable[i - 256];
s[1] = 0;
putfonts8_asc_sht(sht_win, cursor_x, 28, COL8_000000, COL8_FFFFFF, s, 1);
cursor_x += 8;
}
}
if (i == 256 + 0x0e && cursor_x > 8) { /* 退格键 */
/* 用空格键把光标消去后，后移1次光标 */
putfonts8_asc_sht(sht_win, cursor_x, 28, COL8_000000, COL8_FFFFFF, " ", 1);
cursor_x -= 8;
}
/* カーソルの再表示 */
boxfill8(sht_win->buf, sht_win->bxsize, cursor_c, cursor_x, 28, cursor_x + 7, 43);
sheet_refresh(sht_win, cursor_x, 28, cursor_x + 8, 44);
} else if (512 <= i && i <= 767) { /* マウスデータ */
if (mouse_decode(&mdec, i - 512) != 0) {
/* 鼠标的3个字节都齐了，显示出来 */
sprintf(s, "[lcr %4d %4d]", mdec.x, mdec.y);
if ((mdec.btn & 0x01) != 0) {
s[1] = 'L';
}
if ((mdec.btn & 0x02) != 0) {
s[3] = 'R';
}
if ((mdec.btn & 0x04) != 0) {
s[2] = 'C';
}
putfonts8_asc_sht(sht_back, 32, 16, COL8_FFFFFF, COL8_008484, s, 15);
/* 移动鼠标 */
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;
}
sprintf(s, "(%3d, %3d)", mx, my);
putfonts8_asc_sht(sht_back, 0, 0, COL8_FFFFFF, COL8_008484, s, 10);
sheet_slide(sht_mouse, mx, my);
if ((mdec.btn & 0x01) != 0) {
/* 按下左键、移动sht_win */
sheet_slide(sht_win, mx - 80, my - 8);
}
}
} else if (i == 10) { /* 10秒定时器 */
putfonts8_asc_sht(sht_back, 0, 64, COL8_FFFFFF, COL8_008484, "10[sec]", 7);
} else if (i == 3) { /* 3秒定时器 */
putfonts8_asc_sht(sht_back, 0, 80, COL8_FFFFFF, COL8_008484, "3[sec]", 6);
} else if (i <= 1) { /* 光标用定时器 */
if (i != 0) {
timer_init(timer3, &fifo, 0); /* 下面设定0 */
cursor_c = COL8_000000;
} else {
timer_init(timer3, &fifo, 1); /* 下面设定1 */
cursor_c = COL8_FFFFFF;
}
timer_settime(timer3, 50);
boxfill8(sht_win->buf, sht_win->bxsize, cursor_c, cursor_x, 28, cursor_x + 7, 43);
sheet_refresh(sht_win, cursor_x, 28, cursor_x + 8, 44);
}
}
}
}
void HariMain(void)
{
BOOTINFO *binfo = (BOOTINFO *) ADR_BOOTINFO;
MOUSE_DECODE mouse_dec;
MEMMANAGE *memmanage = (MEMMANAGE *)MEMMANAGE_ADDR;
LAYER_MANAGE *layer_manage;
LAYER *layer_bg, *layer_mouse;
char mCursor[mCursorWidth * mCursorHeight];
unsigned char *mBg; //屏幕的大背景会在init_screen的时候画出来，这里只需要一个指向它的指针即可
unsigned char strings[40], keyBuffer[32], mouseBuffer[128],i;
unsigned int memory_total;
int j;
int mCursorX, mCursorY; //鼠标光标显示位置的横纵坐标
mCursorX = binfo->scrnx / 2;
mCursorY = (binfo->scrny - 28)/ 2; //减去下方任务栏的高度
/*内存检查*/
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_fifo(&keyFIFO, 32, keyBuffer); //初始化keyFIFO缓冲区
init_fifo(&mouseFIFO, 128, mouseBuffer); //初始化mouseFIFO缓冲区
/*初始化GDT和IDT表以及PIC板的数据*/
init_GDTandIDT(); //初始化GDT和IDT表
init_pic(); //初始化PIC主从板数据
io_sti(); //开始接收中断
/*若要接收鼠标中断需要两个步骤，首先必须使鼠标控制电路（就是键盘控制电路的一部分）有效，然后要使鼠标本身有效*/
init_keyboard(); //初始化键盘控制器电路
enable_mouse(&mouse_dec); //激活鼠标
/*开放鼠标和键盘中断*/
io_out8(PIC0_IMR, 0xf9); /* PIC0开发IRQ(11111001)，开放IRQ1和IRQ2，键盘中断和从PIC板 */
io_out8(PIC1_IMR, 0xef); /* PIC1开放IRQ(11101111)， 开放鼠标中断*/
/*初始化调色板，为图形界面做准备*/
init_palette(); //初始化调色板
/*初始化图层管理，并且初始化鼠标光标和背景的图层*/
layer_manage = layer_man_init(memmanage, binfo->vram, binfo->scrnx, binfo->scrny);
layer_bg = layer_alloc(layer_manage); //为背景分配图层
layer_mouse = layer_alloc(layer_manage); //为鼠标分配图层
mBg = (unsigned char *)memmanage_alloc_4K(memmanage, binfo->scrnx * binfo->scrny); //为背景图形的内容分配内存
layer_set(layer_bg, mBg, binfo->scrnx, binfo->scrny, -1);
layer_set(layer_mouse, mCursor, 16, 16 ,99);
/*初始化整个桌面背景*/
init_screen(mBg, binfo->scrnx, binfo->scrny); //这个时候的init_screen不再是直接画出背景，而是在mBg内存地址中填写好背景内容
layer_slide(layer_manage, layer_bg, 0, 0); //把背景图层从(0,0)坐标开始画
/*初始化鼠标图标*/
init_mouse_cursor(mCursor, 99); //初始化鼠标光标
layer_slide(layer_manage, layer_mouse, mCursorX, mCursorY); //现在显示图形不需要再用displayShape函数了，直接用这个图层管理的绘图函数就行
layer_switch(layer_manage, layer_bg, 0); //把背景图层调为最底层，高度为0
layer_switch(layer_manage, layer_mouse, 1); //鼠标图层调为第二层，高度为1
//layer_all_refresh(layer_manage);
sprintf(strings, "Memory has %dMB", i);
displayStrings_CS(mBg, binfo->scrnx, 0, 64, COL8_FFFFFF,strings);
layer_refresh(layer_manage, layer_bg, 0, 64, binfo->scrnx, 80);
sprintf(strings, "free memory:%dKB",memmanage_total(memmanage) / 1024);
displayStrings_CS(mBg, binfo->scrnx, 120, 64, COL8_FFFFFF,strings); //用字体显示当前内存容量
layer_refresh(layer_manage, layer_bg, 120, 64, binfo->scrnx, 80);
for(;;)
{
io_cli();
if(0 == fifo_status(&keyFIFO) + fifo_status(&mouseFIFO)) //当前没有中断产生
{
io_stihlt(); //当CPU执行hlt指令之后只有外部中断等之情况才会再次唤醒CPU继续工作
}
else
{
if(0 != fifo_status(&keyFIFO))
{
i = fifo_get(&keyFIFO);
io_sti();
sprintf(strings,"%2X",i);
drawRectangle(mBg, binfo->scrnx, COL8_008484, 0, 0, 16,16); //这里的字体不再是卸载vram中，而是写到mBg这个背景内存中，与背景成为一个图层
displayStrings_CS(mBg, binfo->scrnx, 0, 0, COL8_FFFFFF,strings);
layer_refresh(layer_manage, layer_bg, 0, 0, 16, 16); //由于向背景图层中添加了新东西，需要重绘各个图层
}
else if(0 != fifo_status(&mouseFIFO))
{
i = fifo_get(&mouseFIFO);
io_sti();
if(0 != mouse_decode(&mouse_dec, i)) //只有返回值为1的时候才说明成功接收完成一次鼠标的中断
{
/*显示鼠标的信息*/
sprintf(strings,"[lcr %4d %4d]",mouse_dec.x, mouse_dec.y);
if(0 != (mouse_dec.btn & 0x01)) //按下了左键
{
strings[1] = 'L';
}
if(0 != (mouse_dec.btn & 0x02)) //按下了右键
{
strings[3] = 'R';
}
if(0 != (mouse_dec.btn & 0x04)) //按下了中键
{
strings[2] = 'C';
}
drawRectangle(mBg, binfo->scrnx, COL8_008484, 0, 16, 15 * 8, 16); //用背景色覆盖上次的坐标
displayStrings_CS(mBg, binfo->scrnx, 0, 16, COL8_FFFFFF,strings); //显示新的坐标
layer_refresh(layer_manage, layer_bg,0, 16, 15 * 8, 32);
/*鼠标的移动*/
//根据mouse_dec里存储的鼠标信息画出新的鼠标图像
mCursorX += mouse_dec.x;
mCursorY += mouse_dec.y;
//不能让鼠标移出画面
if(mCursorX < 0)
{
mCursorX = 0;
}
if(mCursorY < 0)
{
mCursorY = 0;
}
if(mCursorX > binfo->scrnx - 16)
{
mCursorX = binfo->scrnx - 16;
}
if(mCursorY > binfo->scrny - 16)
{
mCursorY = binfo->scrny - 16;
}
sprintf(strings, "(%4d %4d)", mCursorX, mCursorY);
drawRectangle(mBg, binfo->scrnx, COL8_008484, 40, 32, 20 * 8,16); //用背景色覆盖上次的坐标
displayStrings_CS(mBg, binfo->scrnx, 40, 32, COL8_FFFFFF,strings); //显示新的坐标
layer_refresh(layer_manage, layer_bg, 40, 32, 20 * 8,48);
layer_slide(layer_manage, layer_mouse, mCursorX, mCursorY);
}
}
}
}
}
void HariMain(void)
{
char *vram;
int xsize;
int ysize;
unsigned int memtotal;
struct MEMMAN *memman = (struct MEMMAN *) MEMMAN_ADDR ;
struct BOOTINFO *binfo;
struct SHTCTL *shtctl;
struct SHEET *sht_back, *sht_mouse, *sht_win;
unsigned char *buf_back, buf_mouse[256],*buf_win;
int i;
int fifobuf[128];
char s[40];
struct FIFO fifo;
fifo_init(&fifo,128,fifobuf);
static char keytable[0x54] = {
0, 0, '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '-', '^', 0, 0,
'Q', 'W', 'E', 'R', 'T', 'Y', 'U', 'I', 'O', 'P', '@', '[', 0, 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', '.'
};
init_gdtidt();
init_pic();
io_sti();
init_pit(); // timer
io_out8(PIC0_IMR, 0xf8); /* PIC1 (11111001) irq0 */
io_out8(PIC1_IMR, 0xef); //11101111 , allow irq12
struct TIMER *timer,*timer2,*timer3;
timer = timer_alloc();
timer2 = timer_alloc();
timer3 = timer_alloc();
timer_set(timer,1000,&fifo,10);
timer_set(timer2,300,&fifo,3);
timer_set(timer3,50,&fifo,1);
init_keyboard(&fifo,256);
// memory test
memtotal = memtest(0x00400000, 0xbfffffff); // available maxmium address
memman_init(memman);
memman_free(memman,0x00001000,0x0009e000);
memman_free(memman,0x00400000,memtotal-0x00400000);
init_palette();
binfo = (struct BOOTINFO *) 0x0ff0;
xsize = binfo->scrnx;
ysize = binfo->scrny;
vram = binfo->vram;
// sheet setting
shtctl = shtctl_init(memman, binfo->vram, binfo->scrnx, binfo->scrny);
sht_back = sheet_alloc(shtctl);
sht_mouse = sheet_alloc(shtctl);
sht_win = sheet_alloc(shtctl);
buf_back = (unsigned char *) memman_alloc_4k(memman, binfo->scrnx * binfo->scrny);
buf_win = (unsigned char *) memman_alloc_4k(memman,160 * 52); // window sheet buffer
sheet_setbuf(sht_back, buf_back, binfo->scrnx, binfo->scrny, -1);
sheet_setbuf(sht_mouse, buf_mouse, 16, 16, 99); // col_inv 99
sheet_setbuf(sht_win, buf_win,160,52,-1);
/* initlize OS background */
init_screen(buf_back,xsize,ysize);
int mx,my; // mouse position
// mouse cursor
struct MOUSE_DEC mdec;
enable_mouse(&fifo,512,&mdec);
init_mouse_cursor8(buf_mouse,99);
make_window8(buf_win,160,52,"window");
mx = (binfo->scrnx - 16) / 2;
my = (binfo->scrny - 28 - 16) / 2;
sheet_move(sht_back,0,0);// move background sheet
sheet_move(sht_mouse,mx,my);
sheet_move(sht_win,80,72);
sheet_updown(sht_back,0); // height 0, at the bottom
sheet_updown(sht_win,1);
sheet_updown(sht_mouse,2); // height 2,on the top
sprintf(s,"%3d %3d",mx,my);
putfonts8_asc(binfo->vram, binfo->scrnx, 0, 0, COL8_FFFFFF, s);
sprintf(s, "memory %dMB free %dkb", memtotal/(1024*1024), memman_total(memman)/1024);
putfonts8_asc(buf_back, binfo->scrnx, 0, 32, COL8_FFFFFF, s);
sheet_refresh(sht_back,0,0,binfo->scrnx,48);
int cursor_x,cursor_c; // cursor color
make_textbox8(sht_win, 8,28,144,16,COL8_FFFFFF); // heigth is 16
cursor_x = 8;
cursor_c = COL8_FFFFFF;
for(;;)
{
//sprintf(s,"%010d",timerctl.count);
//bps(sht_win,40,28, COL8_C6C6C6,COL8_000000,s,10);
io_cli(); // forbid all interrupts
if(fifo_status(&fifo) == 0)
io_stihlt(); // read data until it's empty
else {
i=fifo_get(&fifo);
io_sti(); // open interrupts
if(255 < i && i < 512)
{sprintf(s, "%02X", i-256);
boxfill8(buf_back, binfo->scrnx, COL8_008400, 0, 16, 15, 31);
putfonts8_asc(buf_back, binfo->scrnx, 0, 16, COL8_FFFFFF, s);
sheet_refresh(sht_back,0,16,16,32);
if(i<256 +0x54)
{
if(keytable[i-256] != 0 && cursor_x < 144)
{
s[0]= keytable[i-256];
s[1]= '\0';
bps(sht_win,cursor_x,28, COL8_FFFFFF,COL8_000000,s,1); // 4th parm is background color
cursor_x +=8; // cursor move forward
}
}
if(i == 256 + 0x0e && cursor_x > 8)
{
bps(sht_win,cursor_x,28,COL8_FFFFFF,COL8_000000," ",1);
cursor_x -=8;
}
boxfill8(sht_win ->buf, sht_win->bxsize, cursor_c,cursor_x,28,cursor_x+7,43);
sheet_refresh(sht_win,cursor_x,28,cursor_x+8,44);
}
else if(511 < i && i < 768)
{
if(mouse_decode(&mdec,i-512) != 0)
{ sprintf(s, "[lcr %4d %4d]", mdec.x,mdec.y);
if((mdec.btn & 0x01) != 0) s[1]='L';
if((mdec.btn & 0x02) != 0) s[3]='R';
if((mdec.btn & 0x04) != 0) s[2]='C';
boxfill8(buf_back, binfo->scrnx, COL8_008484, 32, 16, 32+15*8-1, 31); // after filling,show ok
putfonts8_asc(buf_back, binfo->scrnx, 32, 16, COL8_FFFFFF, s);
sheet_refresh(sht_back,32,16,32+15*8,32);
// the move of mouse
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; // control the mouse move area
sprintf(s, "(%3d,%3d)", mx,my);
boxfill8(buf_back, binfo->scrnx, COL8_008484, 0, 0,79, 15);
putfonts8_asc(buf_back, binfo->scrnx, 0, 0, COL8_FFFFFF, s);
sheet_refresh(sht_back,0,0,80,16);
sheet_move(sht_mouse,mx,my);
// move the window, vram -> sht -> move
if(mdec.btn & 0x01 != 0)
sheet_move(sht_win,mx-80,my-8);
}
}
else if(i==10)
{putfonts8_asc(buf_back, binfo->scrnx,0,64, COL8_FFFFFF,"10");
sheet_refresh(sht_back,0,0,100,100);
}
else if(i ==3)
{putfonts8_asc(buf_back, binfo->scrnx,0,80, COL8_FFFFFF,"3s");
sheet_refresh(sht_back,0,0,100,100);
}
else if(i == 1)
{
timer_set(timer3,50,&fifo,0);
boxfill8(sht_win->buf,sht_win->bxsize, COL8_000000, cursor_x, 28,cursor_x+7, 43);
sheet_refresh(sht_win,cursor_x,28,cursor_x + 8, 44);
}
else if(i==0)
{
timer_set(timer3,50,&fifo,1); // keep the data
boxfill8(sht_win->buf,sht_win->bxsize, COL8_FFFFFF,cursor_x, 28,cursor_x + 7, 43);
sheet_refresh(sht_win,cursor_x,28,cursor_x + 8, 44);
}
}
}
}