本篇文章我们要解决一个大问题，那就是鼠标。要让鼠标的移动能够实现，我们得实现完善部分系统中断。同理，中断实现了之后键盘的输入也是一样的道理了。

Day06 - 鼠标前期（中断）

显示鼠标

首先我们需要设计一个鼠标，我们用一个 16 * 16 的矩阵来表示

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
void init_mouse_cursor8(cahr *mouse, char bc)
{
 	static char cursor[16][16] = {
		"**************..",
		"*OOOOOOOOOOO*...",
		"*OOOOOOOOOO*....",
		"*OOOOOOOOO*.....",
		"*OOOOOOOO*......",
		"*OOOOOOO*.......",
		"*OOOOOOO*.......",
		"*OOOOOOOO*......",
		"*OOOO**OOO*.....",
		"*OOO*..*OOO*....",
		"*OO*....*OOO*...",
		"*O*......*OOO*..",
		"**........*OOO*.",
		"*..........*OOO*",
		"............*OO*",
		".............***"
	};
	int x, y;

	for (y = 0; y < 16; y++) {
		for (x = 0; x < 16; x++) {
			if (cursor[y][x] == '*') {
				mouse[y * 16 + x] = COL8_000000;
			}
			if (cursor[y][x] == 'O') {
				mouse[y * 16 + x] = COL8_FFFFFF;
			}
			if (cursor[y][x] == '.') {
				mouse[y * 16 + x] = bc;		// bc = background color
			}
		}
	}
	return;
}

上面这个函数只是鼠标的设计，还需要下面的函数把鼠标画到 VRAM 上去

1
2
3
4
5
6
7
8
9
10
11
void putblock8_8(char *vram, int vxsize, int pxsize,
	int pysize, int px0, int py0, char *buf, int bxsize)
{
	int x, y;
	for (y = 0; y < pysize; y++) {
		for (x = 0; x < pxsize; x++) {
			vram[(py0 + y) * vxsize + (px0 + x)] = buf[y * bxsize + x];
		}
	}
	return;
}

然后只要在 HariMain 中先后调用这两个函数就可以了

1
2
init_mouse_cursor8(mcursor, COL8_008484);
putblock8_8(binfo->vram, binfo->scrnx, 16, 16, mx, my, mcursor, 16);

1

GDT与IDT的初始化

GDT 是 Global (segment) Descriptor Table 的缩写。用来存放段的信息。我们把内存分成一个个段，这些段包含有以下信息：

  • 段的起始地址
  • 段的大小
  • 段的管理属性（禁止写入，禁止执行，系统专用等）

这些属性CPU用8字节（64位）来表示，但是我们的段寄存器只有16位（实际上只有13位有效，也就是表示0～8191），所以我们需要把 8192 * 8 = 65536字节的数据存在内存的某个位置，这64KB的数据就叫做 GDT 。

IDT 则是 Interrupt Descriptor Table 的缩写，用于记录中断信息的。我们使用鼠标的时候就需要调用中断，所以我们要先设定好 IDT 。同时，如果没有写好 GDT 就写 IDT 的话会比较麻烦，所以我们顺手解决掉这个问题。

我们用结构体来存储相关信息：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
struct SEGMENT_DESCRIPTOR
/* GDT */
{ 
  short limit_low, base_low; 
  char base_mid, access_right; 
  char limit_high, base_high; 
};

struct GATE_DESCRIPTOR 
/* IDT */
{ 
  short offset_low, selector; 
  char dw_count, access_right; 
  short offset_high; 
};

初始化函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
void init_gdtidt(void) 
{ 
  struct SEGMENT_DESCRIPTOR *gdt = (struct SEGMENT_DESCRIPTOR *) 0x00270000;
  struct GATE_DESCRIPTOR *idt = (struct GATE_DESCRIPTOR *) 0x0026f800; 
  int i; 
  
  /* GDT的初始化 */ 
  for (i = 0; i < 8192; i++) { 
    set_segmdesc(gdt + i, 0, 0, 0);    /* 设置一个段8字节的信息 */
  }
  /* 0xffffffff = 4GB 表示可以使用 CPU全部的内存 */
	set_segmdesc(gdt + 1, 0xffffffff, 0x00000000, 0x4092); 
  /* 可以执行 bootpack.hrb */
  set_segmdesc(gdt + 2, 0x0007ffff, 0x00280000, 0x409a); 
  load_gdtr(0xffff, 0x00270000); 
  
  /* IDT的初始化 */ 
  for (i = 0; i < 256; i++) { 
    set_gatedesc(idt + i, 0, 0, 0); 
  }
  load_idtr(0x7ff, 0x0026f800); 
  
  return; 
}

设置函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
void set_segmdesc(struct SEGMENT_DESCRIPTOR *sd, unsigned int limit, int base, int ar) 
{ 
  if (limit > 0xfffff) { 
    ar |= 0x8000; 
    /* G_bit = 1 */ 
    limit /= 0x1000; 
  }
  sd->limit_low = limit & 0xffff; 
  sd->base_low = base & 0xffff; 
  sd->base_mid = (base >> 16) & 0xff; 
  sd->access_right = ar & 0xff; 
  sd->limit_high = ((limit >> 16) & 0x0f) |((ar >> 8) & 0xf0); 
  sd->base_high = (base >> 24) & 0xff; 
  
  return; 
}

void set_gatedesc(struct GATE_DESCRIPTOR *gd, int offset, int selector, int ar) { 
  gd->offset_low = offset & 0xffff; 
  gd->selector = selector; 
  gd->dw_count = (ar >> 8) & 0xff; 
  gd->access_right = ar & 0xff; 
  gd->offset_high = (offset >> 16) & 0xffff; 
  
  return; 
}

这里我们还需要一个函数把 GDT 和 IDT 里的信息移到相应寄存器里，所以我们在 naskfunc.nas 里添加以下两个函数：

1
2
3
4
5
6
7
8
9
10
11
_load_gdtr:
		MOV	AX, [ESP+4]
		MOV	[ESP+6], AX
		LGDT	[ESP+6]
		RET
		
_load_idtr:
		MOV	AX, [ESP+4]
		MOV	[ESP+6], AX
		LIDT	[ESP+6]
		RET

这样我们就实现了这两个表。

中断

我们完成了 IDT 的编写，下面要做的就是实现中断处理程序（代码会在后面给出，这里就举个例子）。

我们新建一个文件 int.c里面储存各种中断处理程序

1
2
3
4
5
6
7
8
9
10
void inthandler21(int *esp)
/* 来自PS/2键盘的中断 */
{
	struct BOOTINFO *binfo = (struct BOOTINFO *) ADR_BOOTINFO;
	boxfill8(binfo->vram, binfo->scrnx, COL8_000000, 0, 0, 32 * 8 - 1, 15);
	putfonts8_asc(binfo->vram, binfo->scrnx, 0, 0, COL8_FFFFFF, "INT 21 (IRQ-1) : PS/2 keyboard");
	for (;;) {
		io_hlt();
	}
}

同时我们还要在 naskfunc.nas 中增加相应的调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
_asm_inthandler21:
		PUSH	ES
		PUSH	DS
		PUSHAD
		MOV		EAX,ESP
		PUSH	EAX
		MOV		AX,SS
		MOV		DS,AX
		MOV		ES,AX
		CALL	_inthandler21
		POP		EAX
		POPAD
		POP		DS
		POP		ES
		IRETD

这样一个中断就处理好了。他的作用就是敲击键盘的时候在屏幕左上角可以显示一串字符。

代码整理

这个时候我们的 bootpack.c 就过于冗长了，我们把他拆分成四个部分

bootpack.h :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
/* asmhead.nas */
struct BOOTINFO {
	char cyls, leds, vmode, reserve;
	short scrnx, scrny;
	char *vram;
};
#define ADR_BOOTINFO 0x00000ff0

/* nasfunc.nas */
void io_hlt(void);
void io_cli(void);
void io_out8(int port, int data);
int io_load_eflags(void);
void io_store_eflags(int eflags);
void load_gdtr(int limit, int addr);
void load_idtr(int limit, int addr);
void asm_inthandler21(void);
void asm_inthandler27(void);
void asm_inthandler2c(void);

/* graphic.c */
void init_palette(void);
void set_palette(int start, int end, unsigned char *rgb);
void boxfill8(unsigned char *vram, int xsize, unsigned char c, int x0, int y0, int x1, int y1);
void init_screen(char *vram, int x, int y);
void putfont8(char *vram, int xsize, int x, int y, char c, char *font);
void putfonts8_asc(char *vram, int xsize, int x, int y, char c, unsigned char *s);
void init_mouse_cursor8(char *mouse, char bc);
void putblock8_8(char *vram, int vxsize, int pxsize,
	int pysize, int px0, int py0, char *buf, int bxsize);
#define COL8_000000		0
#define COL8_FF0000		1
#define COL8_00FF00		2
#define COL8_FFFF00		3
#define COL8_0000FF		4
#define COL8_FF00FF		5
#define COL8_00FFFF		6
#define COL8_FFFFFF		7
#define COL8_C6C6C6		8
#define COL8_840000		9
#define COL8_008400		10
#define COL8_848400		11
#define COL8_000084		12
#define COL8_840084		13
#define COL8_008484		14
#define COL8_848484		15

/* dsctbl.c */
struct SEGMENT_DESCRIPTOR {
	short limit_low, base_low;
	char base_mid, access_right;
	char limit_high, base_high;
};

struct GATE_DESCRIPTOR {
	short offset_low, selector;
	char dw_count, access_right;
	short offset_high;
};
void init_gdtidt(void);
void set_segmdesc(struct SEGMENT_DESCRIPTOR *sd, unsigned int limit, int base, int ar);
void set_gatedesc(struct GATE_DESCRIPTOR *gd, int offset, int selector, int ar);
#define ADR_IDT			0x0026f800
#define LIMIT_IDT		0x000007ff
#define ADR_GDT			0x00270000
#define LIMIT_GDT		0x0000ffff
#define ADR_BOTPAK		0x00280000
#define LIMIT_BOTPAK	0x0007ffff
#define AR_DATA32_RW	0x4092
#define AR_CODE32_ER	0x409a
#define AR_INTGATE32	0x008e

/* int.c */
void init_pic(void);
void inthandler21(int *esp);
void inthandler27(int *esp);
void inthandler2c(int *esp);
#define PIC0_ICW1		0x0020
#define PIC0_OCW2		0x0020
#define PIC0_IMR		0x0021
#define PIC0_ICW2		0x0021
#define PIC0_ICW3		0x0021
#define PIC0_ICW4		0x0021
#define PIC1_ICW1		0x00a0
#define PIC1_OCW2		0x00a0
#define PIC1_IMR		0x00a1
#define PIC1_ICW2		0x00a1
#define PIC1_ICW3		0x00a1
#define PIC1_ICW4		0x00a1

bootpack.c:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#include "bootpack.h"
#include <stdio.h>

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_screen(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);
	io_out8(PIC1_IMR, 0xef);

	for (;;) {
		io_hlt();
	}
}

dsctbl.c : 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
include "bootpack.h"

void init_gdtidt(void)
{
	struct SEGMENT_DESCRIPTOR *gdt = (struct SEGMENT_DESCRIPTOR *) ADR_GDT;
	struct GATE_DESCRIPTOR    *idt = (struct GATE_DESCRIPTOR    *) ADR_IDT;
	int i;

	/* GDT的初始化 */
	for (i = 0; i < LIMIT_GDT / 8; i++) {
		set_segmdesc(gdt + i, 0, 0, 0);
	}
	set_segmdesc(gdt + 1, 0xffffffff, 0x00000000, AR_DATA32_RW);
	set_segmdesc(gdt + 2, LIMIT_BOTPAK, ADR_BOTPAK, AR_CODE32_ER);
	load_gdtr(LIMIT_GDT, ADR_GDT);

	/* IDT的初始化 */
	for (i = 0; i < LIMIT_IDT / 8; i++) {
		set_gatedesc(idt + i, 0, 0, 0);
	}
	load_idtr(LIMIT_IDT, ADR_IDT);

	set_gatedesc(idt + 0x21, (int) asm_inthandler21, 2 * 8, AR_INTGATE32);
	set_gatedesc(idt + 0x27, (int) asm_inthandler27, 2 * 8, AR_INTGATE32);
	set_gatedesc(idt + 0x2c, (int) asm_inthandler2c, 2 * 8, AR_INTGATE32);

	return;
}

void set_segmdesc(struct SEGMENT_DESCRIPTOR *sd, unsigned int limit, int base, int ar)
{
	if (limit > 0xfffff) {
		ar |= 0x8000; /* G_bit = 1 */
		limit /= 0x1000;
	}
	sd->limit_low    = limit & 0xffff;
	sd->base_low     = base & 0xffff;
	sd->base_mid     = (base >> 16) & 0xff;
	sd->access_right = ar & 0xff;
	sd->limit_high   = ((limit >> 16) & 0x0f) | ((ar >> 8) & 0xf0);
	sd->base_high    = (base >> 24) & 0xff;
	return;
}

void set_gatedesc(struct GATE_DESCRIPTOR *gd, int offset, int selector, int ar)
{
	gd->offset_low   = offset & 0xffff;
	gd->selector     = selector;
	gd->dw_count     = (ar >> 8) & 0xff;
	gd->access_right = ar & 0xff;
	gd->offset_high  = (offset >> 16) & 0xffff;
	return;
}

graphic.c : 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
#include "bootpack.h"

void init_palette(void)
{
	static unsigned char table_rgb[16 * 3] = {
		0x00, 0x00, 0x00,	/*  0:黑 */
		0xff, 0x00, 0x00,	/*  1:亮红 */
		0x00, 0xff, 0x00,	/*  2:亮绿 */
		0xff, 0xff, 0x00,	/*  3:亮黄 */
		0x00, 0x00, 0xff,	/*  4:亮蓝 */
		0xff, 0x00, 0xff,	/*  5:亮紫 */
		0x00, 0xff, 0xff,	/*  6:浅亮蓝 */
		0xff, 0xff, 0xff,	/*  7:白 */
		0xc6, 0xc6, 0xc6,	/*  8:亮灰 */
		0x84, 0x00, 0x00,	/*  9:暗红 */
		0x00, 0x84, 0x00,	/* 10:暗绿 */
		0x84, 0x84, 0x00,	/* 11:暗黄 */
		0x00, 0x00, 0x84,	/* 12:暗青 */
		0x84, 0x00, 0x84,	/* 13:暗紫 */
		0x00, 0x84, 0x84,	/* 14:浅暗紫 */
		0x84, 0x84, 0x84	/* 15:暗灰 */
	};
	set_palette(0, 15, table_rgb);
	return;
}

void init_screen(char *vram, int x, int y)
{
	boxfill8(vram, x, COL8_008484,  0,     0,      x -  1, y - 29);
	boxfill8(vram, x, COL8_C6C6C6,  0,     y - 28, x -  1, y - 28);
	boxfill8(vram, x, COL8_FFFFFF,  0,     y - 27, x -  1, y - 27);
	boxfill8(vram, x, COL8_C6C6C6,  0,     y - 26, x -  1, y -  1);

	boxfill8(vram, x, COL8_FFFFFF,  3,     y - 24, 59,     y - 24);
	boxfill8(vram, x, COL8_FFFFFF,  2,     y - 24,  2,     y -  4);
	boxfill8(vram, x, COL8_848484,  3,     y -  4, 59,     y -  4);
	boxfill8(vram, x, COL8_848484, 59,     y - 23, 59,     y -  5);
	boxfill8(vram, x, COL8_000000,  2,     y -  3, 59,     y -  3);
	boxfill8(vram, x, COL8_000000, 60,     y - 24, 60,     y -  3);

	boxfill8(vram, x, COL8_848484, x - 47, y - 24, x -  4, y - 24);
	boxfill8(vram, x, COL8_848484, x - 47, y - 23, x - 47, y -  4);
	boxfill8(vram, x, COL8_FFFFFF, x - 47, y -  3, x -  4, y -  3);
	boxfill8(vram, x, COL8_FFFFFF, x -  3, y - 24, x -  3, y -  3);
	return;
}

void set_palette(int start, int end, unsigned char *rgb)
{
	int i, eflags;
	eflags = io_load_eflags();	/* 记录中断许可标志 */
	io_cli(); 					/* 将中断许可标志置0，表示禁止中断 */
	io_out8(0x03c8, start);
	for (i = start; i <= end; i++) {
		io_out8(0x03c9, rgb[0] / 4);
		io_out8(0x03c9, rgb[1] / 4);
		io_out8(0x03c9, rgb[2] / 4);
		rgb += 3;
	}
	io_store_eflags(eflags);	/* 复原中断许可标志 */
	return;
}

void boxfill8(unsigned char *vram, int xsize, unsigned char c, int x0, int y0, int x1, int y1)
{
	int x, y;
	for (y = y0; y <= y1; y++) {
		for (x = x0; x <= x1; x++)
			vram[y * xsize + x] = c;
	}
	return;
}

void putfont8(char *vram, int xsize, int x, int y, char c, char *font)
{
	int i;
	char *p, d /* data */;
	for (i = 0; i < 16; i++) {
		p = vram + (y + i) * xsize + x;
		d = font[i];
		if ((d & 0x80) != 0) { p[0] = c; }
		if ((d & 0x40) != 0) { p[1] = c; }
		if ((d & 0x20) != 0) { p[2] = c; }
		if ((d & 0x10) != 0) { p[3] = c; }
		if ((d & 0x08) != 0) { p[4] = c; }
		if ((d & 0x04) != 0) { p[5] = c; }
		if ((d & 0x02) != 0) { p[6] = c; }
		if ((d & 0x01) != 0) { p[7] = c; }
	}
	return;
}

void putfonts8_asc(char *vram, int xsize, int x, int y, char c, unsigned char *s)
{
	extern char hankaku[4096];

	for(; *s != 0x00; s++) {
		putfont8(vram, xsize, x, y, c, hankaku + *s * 16);
		x += 8;
	}
	return;
}

void init_mouse_cursor8(char *mouse, char bc)
/* 准备鼠标指针（16x16） */
{
	static char cursor[16][16] = {
		"**************..",
		"*OOOOOOOOOOO*...",
		"*OOOOOOOOOO*....",
		"*OOOOOOOOO*.....",
		"*OOOOOOOO*......",
		"*OOOOOOO*.......",
		"*OOOOOOO*.......",
		"*OOOOOOOO*......",
		"*OOOO**OOO*.....",
		"*OOO*..*OOO*....",
		"*OO*....*OOO*...",
		"*O*......*OOO*..",
		"**........*OOO*.",
		"*..........*OOO*",
		"............*OO*",
		".............***"
	};
	int x, y;

	for (y = 0; y < 16; y++) {
		for (x = 0; x < 16; x++) {
			if (cursor[y][x] == '*') {
				mouse[y * 16 + x] = COL8_000000;
			}
			if (cursor[y][x] == 'O') {
				mouse[y * 16 + x] = COL8_FFFFFF;
			}
			if (cursor[y][x] == '.') {
				mouse[y * 16 + x] = bc;		// bc = background color
			}
		}
	}
	return;
}

void putblock8_8(char *vram, int vxsize, int pxsize,
	int pysize, int px0, int py0, char *buf, int bxsize)
{
	int x, y;
	for (y = 0; y < pysize; y++) {
		for (x = 0; x < pxsize; x++) {
			vram[(py0 + y) * vxsize + (px0 + x)] = buf[y * bxsize + x];
		}
	}
	return;
}

然后对 naskfunc.nas 和 Makefile 都作了修改。

naskfunc.nas : 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
; naskfunc
; TAB=4

[FORMAT "WCOFF"]        ; 制作目标文件的模式
[INSTRSET "i486p"]				; 

[BITS 32]               ; 制作32位模式用的机械语言

; 制作目标文件的信息

[FILE "naskfunc.nas"]   ; 源文件名信息

    GLOBAL	_io_hlt, _io_cli, _io_sti, _io_stihlt
	GLOBAL	_io_in8,  _io_in16,  _io_in32
	GLOBAL	_io_out8, _io_out16, _io_out32
	GLOBAL	_io_load_eflags, _io_store_eflags
	GLOBAL	_load_gdtr, _load_idtr
	GLOBAL _asm_inthandler21, _asm_inthandler27, _asm_inthandler2c
	EXTERN	_inthandler21, _inthandler27, _inthandler2c

; 以下是实际的函数

[SECTION .text]

_io_hlt:	; void io_hlt(void);
		HLT
		RET

_io_cli:	; void io_cli(void);
		CLI
		RET

_io_sti:	; void io_sti(void);
		STI
		RET

_io_stihlt:	; void io_stihlt(void);
		STI
		HLT
		RET

_io_in8:	; int io_in8(int port);
		MOV		EDX,[ESP+4]		; port
		MOV		EAX,0
		IN		AL,DX
		RET

_io_in16:	; int io_in16(int port);
		MOV		EDX,[ESP+4]		; port
		MOV		EAX,0
		IN		AX,DX
		RET

_io_in32:	; int io_in32(int port);
		MOV		EDX,[ESP+4]		; port
		IN		EAX,DX
		RET

_io_out8:	; void io_out8(int port, int data);
		MOV		EDX,[ESP+4]		; port
		MOV		AL,[ESP+8]		; data
		OUT		DX,AL
		RET

_io_out16:	; void io_out16(int port, int data);
		MOV		EDX,[ESP+4]		; port
		MOV		EAX,[ESP+8]		; data
		OUT		DX,AX
		RET

_io_out32:	; void io_out32(int port, int data);
		MOV		EDX,[ESP+4]		; port
		MOV		EAX,[ESP+8]		; data
		OUT		DX,EAX
		RET

_io_load_eflags:	; int io_load_eflags(void);
		PUSHFD		; PUSH EFLAGS  Ƃ    Ӗ 
		POP		EAX
		RET

_io_store_eflags:	; void io_store_eflags(int eflags);
		MOV		EAX,[ESP+4]
		PUSH	EAX
		POPFD		; POP EFLAGS  Ƃ    Ӗ 
		RET

_load_gdtr:		; void load_gdtr(int limit, int addr);
		MOV		AX,[ESP+4]		; limit
		MOV		[ESP+6],AX
		LGDT	[ESP+6]
		RET

_load_idtr:		; void load_idtr(int limit, int addr);
		MOV		AX,[ESP+4]		; limit
		MOV		[ESP+6],AX
		LIDT	[ESP+6]
		RET

_asm_inthandler21:
		PUSH	ES
		PUSH	DS
		PUSHAD
		MOV		EAX,ESP
		PUSH	EAX
		MOV		AX,SS
		MOV		DS,AX
		MOV		ES,AX
		CALL	_inthandler21
		POP		EAX
		POPAD
		POP		DS
		POP		ES
		IRETD

_asm_inthandler27:
		PUSH	ES
		PUSH	DS
		PUSHAD
		MOV		EAX,ESP
		PUSH	EAX
		MOV		AX,SS
		MOV		DS,AX
		MOV		ES,AX
		CALL	_inthandler27
		POP		EAX
		POPAD
		POP		DS
		POP		ES
		IRETD

_asm_inthandler2c:
		PUSH	ES
		PUSH	DS
		PUSHAD
		MOV		EAX,ESP
		PUSH	EAX
		MOV		AX,SS
		MOV		DS,AX
		MOV		ES,AX
		CALL	_inthandler2c
		POP		EAX
		POPAD
		POP		DS
		POP		ES
		IRETD

Makefile :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
OBJS_BOOTPACK = bootpack.obj naskfunc.obj hankaku.obj \
                    graphic.obj dsctbl.obj int.obj
TOOLPATH = ../z_tools/
INCPATH  = ../z_tools/haribote/

MAKE     = $(TOOLPATH)make.exe -r
NASK     = $(TOOLPATH)nask.exe
CC1      = $(TOOLPATH)cc1.exe -I$(INCPATH) -Os -Wall -quiet
GAS2NASK = $(TOOLPATH)gas2nask.exe -a
OBJ2BIM  = $(TOOLPATH)obj2bim.exe
MAKEFONT = $(TOOLPATH)makefont.exe
BIN2OBJ  = $(TOOLPATH)bin2obj.exe
BIM2HRB  = $(TOOLPATH)bim2hrb.exe
RULEFILE = $(TOOLPATH)haribote/haribote.rul
EDIMG    = $(TOOLPATH)edimg.exe
IMGTOL   = $(TOOLPATH)imgtol.com
COPY     = copy
DEL      = del

default :
	$(MAKE) img

ipl10.bin : ipl10.nas Makefile
	$(NASK) ipl10.nas ipl10.bin ipl10.lst

asmhead.bin : asmhead.nas Makefile
	$(NASK) asmhead.nas asmhead.bin asmhead.lst

hankaku.bin : hankaku.txt Makefile
	$(MAKEFONT) hankaku.txt hankaku.bin

hankaku.obj : hankaku.bin Makefile
	$(BIN2OBJ) hankaku.bin hankaku.obj _hankaku

bootpack.bim : $(OBJS_BOOTPACK) Makefile
	$(OBJ2BIM) @$(RULEFILE) out:bootpack.bim stack:3136k map:bootpack.map \
		$(OBJS_BOOTPACK)
# 3MB+64KB=3136KB

bootpack.hrb : bootpack.bim Makefile
	$(BIM2HRB) bootpack.bim bootpack.hrb 0

haribote.sys : asmhead.bin bootpack.hrb Makefile
	copy /B asmhead.bin+bootpack.hrb haribote.sys

haribote.img : ipl10.bin haribote.sys Makefile
	$(EDIMG)   imgin:../z_tools/fdimg0at.tek \
		wbinimg src:ipl10.bin len:512 from:0 to:0 \
		copy from:haribote.sys to:@: \
		imgout:haribote.img

%.gas : %.c Makefile
	$(CC1) -o $*.gas $*.c

%.nas : %.gas Makefile
	$(GAS2NASK) $*.gas $*.nas

%.obj : %.nas Makefile
	$(NASK) $*.nas $*.obj $*.lst

img :
	$(MAKE) haribote.img

clean :
	-$(DEL) *.bin
	-$(DEL) *.lst
	-$(DEL) *.obj
	-$(DEL) bootpack.map
	-$(DEL) bootpack.bim
	-$(DEL) bootpack.hrb
	-$(DEL) haribote.sys

src_only :
	$(MAKE) clean

运行结果如下：

敲击键盘前

2

敲击键盘后

3

Day07 - FIFO与鼠标控制

获取按键编码

这一步其实很简单，键盘按键编码其实会通过端口 0x0060 传入，我们只需要调用 io_in8 函数就可以得到编码了。所以我们修改一下 int.c 中的 void inthandler(int *esp) ：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#define PORT_KEYDAT 0x0060
void inthandler21(int *esp)
/* 来自PS/2键盘的中断 */
{
	struct BOOTINFO *binfo = (struct BOOTINFO *) ADR_BOOTINFO;
	unsigned char data, s[4];
  io_out8(PIC_OCW2, 0x61);	/* 通知PIC"IRQ- 01已经受理完毕" */ 
  data = io_in8(PORT_KEYDAT); 
  sprintf(s, "%02X", data); 
  boxfill8(binfo->vram, binfo->scrnx, COL8_008484, 0, 16, 15, 31); 
  putfonts8_asc(binfo->vram, binfo->scrnx, 0, 16, COL8_FFFFFF, s); 
  
  return;
}

4

缓冲区

但上面那种写法不好，因为一敲键盘CPU就会中断来处理键盘事物，比如你正在移动的鼠标就会卡死，所以我们需要增加缓冲区，来储存键盘的输入。最简单的方法就是用一个结构体来储存

结构体写在 bootpack.h 里：

1
2
3
4
struct KEYBUF {
  int flag;
  unsigned char data; 
};

更改 int.c 中的中断程序：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
struct KEYBUF keybuf;

#define PORT_KEYDAT 0x0060

void inthandler21(int *esp)
/* 来自PS/2键盘的中断 */
{
	struct BOOTINFO *binfo = (struct BOOTINFO *) ADR_BOOTINFO;
	unsigned char data, s[4];
  io_out8(PIC_OCW2, 0x61);	/* 通知PIC"IRQ- 01已经受理完毕" */ 
  data = io_in8(PORT_KEYDAT); 
  if(keybuf.flag == 0) {	/* 表示缓冲区空，可以读入数据 */
    keybuf.data = data;
    keybuf.flag = 1;
  } 
  
  return;
}

在 bootpack.c 中实现剩余功能（修改最后的for循环）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
for(;;) {
  io_cli();	/* 先禁止中断 */
  if(key_buf.data == 0) {
    io_stihlt();	
  }
  else {
    i = keybuf.data;
    keybuf.flag = 0;
    io_sti();
    sprintf(s, "%02X", i);
    boxfill8(binfo->vram, binifo->scrnx, COL8_008484, 0, 16, 15, 31);
    putfonts8_asc(binfo->vram, binfo->scrnx, 0, 16, COL8_FFFFFF, s);
  }
}

这样一个简单的缓冲区就做好了。当然这个缓冲区只能储存一个字符，所以我们可以引入栈。整理一下代码如下。

fifo.c :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
#include "bootpack.h"

#define FLAGS_OVERRUN 0x0001

void fifo8_init(struct FIFO8 *fifo, int size, unsigned char *buf)
/* 初始化FIFO缓冲区 */
{
    fifo->size = size;
    fifo->buf = buf;
    fifo->free = size;  /* 缓冲区的大小 */
    fifo->flags = 0;
    fifo->p = 0;    /* 下一个数据写入位置 */
    fifo->q = 0;    /* 下一个数据读出位置 */

    return;
}

int fifo8_put(struct FIFO8 *fifo, unsigned char data)
/* 向FIFO传送数据并保存 */
{
    if(fifo->free == 0) {
        /* 空余没有了，溢出 */
        fifo->flags |= FLAGS_OVERRUN;
        return -1;
    }
    fifo->buf[fifo->p] = data;
    fifo->p++;
    if(fifo->p == fifo->size) {
        fifo->p = 0;
    }
    fifo->free--;
    return 0;
}

int fifo8_get(struct FIFO8 *fifo)
/* 从FIFO取得一个数据 */
{
    int data;
    if(fifo->free == fifo->size) {
        /* 如果缓冲区为空，则返回 -1 */
        return -1;
    }
    data = fifo->buf[fifo->q];
    fifo->q++;
    if(fifo->q == fifo->size) {
        fifo->q = 0;
    }
    fifo->free++;
    return data;
}
int fifo8_status(struct FIFO8 *fifo)
/* 报告一下到底有多少数据 */
{
    return fifo->size - fifo->free;
}

头文件 bootpack.h 增加下面的代码，并删除之前初版缓冲区

1
2
3
4
5
6
7
8
9
/* fifo.c */
struct FIFO8 {
	unsigned char *buf;
	int p, q, size, free, flags;
};
void fifo8_init(struct FIFO8 *fifo, int size, unsigned char *buf);
int fifo8_put(struct FIFO8 *fifo, unsigned char data);
int fifo8_get(struct FIFO8 *fifo);
int fifo8_status(struct FIFO8 *fifo);

然后修改 int.c 中的 void inthandler21(int *esp) :

1
2
3
4
5
6
7
8
9
10
11
#define PORT_KEYDAT 0x0060
struct FIFO8 keyfifo;

void inthandler21(int *esp)
{
  unsigned cahr data;
  io_out8(PIC0_OCW2, 0x61);
  data = io_in8(PORT_KEYDAT);
  fifo8_put(&keyfifo, data);
  return;
}

最后修改 bootpack.c 的for循环

1
2
3
4
5
6
7
8
9
10
11
12
13
for(;;) {
  io_cli();	/* 先禁止中断 */
  if(fifo8_status(&keyfifo) == 0) {
    io_stihlt();	
  }
  else {
    i = fifo8_get(&keyfifo)
    io_sti();
    sprintf(s, "%02X", i);
    boxfill8(binfo->vram, binifo->scrnx, COL8_008484, 0, 16, 15, 31);
    putfonts8_asc(binfo->vram, binfo->scrnx, 0, 16, COL8_FFFFFF, s);
  }
}

鼠标的处理和键盘如出一辙。

鼠标处理

与键盘一样我们增加鼠标的初始函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
#define PORT_KEYDAT 0x0060 
#define PORT_KEYSTA 0x0064 
#define PORT_KEYCMD 0x0064 
#define KEYSTA_SEND_NOTREADY 0x02 
#define KEYCMD_WRITE_MODE 0x60 
#define KBC_MODE 0x47 

void wait_KBC_sendready(void) 
{ 
  /* 等待键盘控制电路准备完毕 */ 
  for (;;) { 
    if ((io_in8(PORT_KEYSTA) & KEYSTA_SEND_NOTREADY) == 0) { 
      break; 
    } 
  }
  return; 
}

void init_keyboard(void) 
{ 
  /* 初始化键盘控制电路 */ 
  wait_KBC_sendready(); 
  io_out8(PORT_KEYCMD, KEYCMD_WRITE_MODE); 
  wait_KBC_sendready(); 
  io_out8(PORT_KEYDAT, KBC_MODE); 
  
  return; 
}

#define KEYCMD_SENDTO_MOUSE 0xd4 
#define MOUSECMD_ENABLE 0xf4

void enable_mouse(void) 
{ 
  /* 激活鼠标 */ 
  wait_KBC_sendready(); 
  io_out8(PORT_KEYCMD, KEYCMD_SENDTO_MOUSE); 
  wait_KBC_sendready(); 
  io_out8(PORT_KEYDAT, MOUSECMD_ENABLE); 
  
  return; /* 顺利的话,键盘控制其会返送回 ACK(0xfa)*/ 
}

然后这个时候运行可以成功在左上角显示那句话了，但是我们修改一下中断程序，直接随时读取。

1
2
3
4
5
6
7
8
9
10
11
12
13
struct FIFO8 mousefifo; 

void inthandler2c(int *esp) 
  /* 来自PS/2鼠标的中断 */ 
{ 
  unsigned char data; 
  io_out8(PIC1_OCW2, 0x64); /* 通知PIC1 IRQ-12的受理已经完成 */ 
  io_out8(PIC0_OCW2, 0x62); /* 通知PIC0 IRQ-02的受理已经完成 */ 
  data = io_in8(PORT_KEYDAT); 
  fifo8_put(&mousefifo, data); 
  
  return; 
}

然后像之前写键盘那样，修改一下 bootpack.c 的for循环

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
fifo8_init(&mousefifo, 128, mousebuf); 

for (;;) 
{ 
  io_cli(); 
  if (fifo8_status(&keyfifo) + fifo8_status(&mousefifo) == 0) { 
    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); 
    } 
  } 
}

5

第二个数字是鼠标，第一个是键盘。鼠标移动的时候第二个数字会实时变化。这样我们就能实现从鼠标获得数据了。

Day08 - 鼠标的终极控制：移动

传入数据的处理

鼠标会传入三个字节的数据，分别表示按键状态、左右移动、上下移动。和键盘一样我们用一个结构体记录这些数据。

1
2
3
4
5
struct MOUSE_DEC {
  unsigned char buf[3], phase;
  /* buf用于存三个字节的数据 */
  /* phase记录当前读入状态了来决定下一个读入的字节 */
}

我们要在激活鼠标的时候为 phase 赋初值。所以要修改 enable_mouse 函数

1
2
3
4
5
6
7
8
9
10
void enable_mouse(struct MOUSE_DEC *mdec)	/* 增加传入的结构体参数 */
{
  wait_KBC_sendready();
  io_out8(PORT_KEYCMD, KEYCMD_SENDTO_MOUSE);
  wait_KBC_sendready();
  io_out8(PORT_KEYCMD, KEYCMD_SENDTO_MOUSE);
  /* 增加初始化 */
  mdec->phase = 0;
  return;
}

增加读入三字节数据的函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
int mouse_decode(struct MOUSE_DEC *mdec, unsigned char dat) 
{ 
  if (mdec->phase == 0) { 
    /* 等待鼠标的0xfa的阶段 */ 
    if (dat == 0xfa) { 
      mdec->phase = 1; 
    }
    return 0; 
  }
  if (mdec->phase == 1) {
    /* 等待鼠标第一字节的阶段 */ 
    mdec->buf[0] = dat; 
    mdec->phase = 2; 
    return 0; 
  }
  if (mdec->phase == 2) { 
    /* 等待鼠标第二字节的阶段 */ 
    mdec->buf[1] = dat; 
    mdec->phase = 3; 
    return 0; 
  }
  if (mdec->phase == 3) { 
    /* 等待鼠标第二字节的阶段 */ 
    mdec->buf[2] = dat; 
    mdec->phase = 1; 
    return 1; 
  }
  return -1; /* 应该不可能到这里来 */ 
}

修改 HariMain

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
struct MOUSE_DEC { 
  unsigned char buf[3], phase; 
};

void enable_mouse(struct MOUSE_DEC *mdec); 
int mouse_decode(struct MOUSE_DEC *mdec, unsigned char dat); 

void HariMain(void) 
{ 
  （中略） 
    struct MOUSE_DEC mdec; 
  （中略）
    enable_mouse(&mdec); 
  
  	for (;;) { 
      io_cli(); 
      if (fifo8_status(&keyfifo) + fifo8_status(&mousefifo) == 0) {
        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(); 
          if (mouse_decode(&mdec, i) != 0) { 
            /* 3字节都凑齐了，所以把它们 显示出来*/ 
            sprintf(s, "%02X %02X %02X", mdec.buf[0], mdec.buf[1], mdec.buf[2]); 
            boxfill8(binfo->vram, binfo->scrnx, COL8_008484, 32, 16, 32 + 8 * 8 - 1, 31); 
            putfonts8_asc(binfo->vram, binfo->scrnx, 32, 16, COL8_FFFFFF, s);
          } 
        }
      } 
    } 
}

运行后显示效果如下

6

第一个字节 0xmn，m的数值必须在0-3这个范围内，所以这意味着该字节的第6、7两个比特位必须为0，n的值必须在8-F之间，这意味着该字节数据对应的第4个比特位必须为1。左键，滚轮，右键被按下时，n的最低3位会被置1。

第二个字节用来表示鼠标的左右移动，对该字节进行相应处理后，可以得到鼠标平移的坐标变换。

第三个字节的数据表示鼠标的上下移动，对该字节进行相应处理后，可以得到鼠标垂直移动时的坐标变换。

移动

好了，我们现在已经成功读到鼠标传入的数据了，我们下一步就是结合这些数据实现鼠标的移动了。

其实这个移动很简单，核心思想就是在鼠标原来的位置用背景色将原来的鼠标盖掉，再在新位置绘制一个鼠标。所以我们现在在鼠标结构体里增加新内容

1
2
3
4
struct MOUSE_DEC {
  unsigned char buf[3], phase;
 	int x, y, btn;	/* btn是储存按键状态 */
}

修改 mouse_decode 函数。我们在读第一个字节数据的时候还得先检查是否满足格式。在第三个字节数据读完之后我们再对鼠标的 x, y, btn 等信息进行完善。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
int mouse_decode(struct MOUSE_DEC *mdec, unsigned char dat)
{
	if (mdec->phase == 0) {
		/* 等待鼠标0xfa阶段 */
		if (dat == 0xfa) {
			mdec->phase = 1;
		}
		return 0;
	}
	if (mdec->phase == 1) {
		/* 等待读取鼠标第一字节 */
		if((dat & 0xc8) == 0x08) {
			mdec->buf[0] = dat;
			mdec->phase = 2;
		}
		return 0;
	}
	if (mdec->phase == 2) {
		/* 等待读取鼠标第二字节 */
		mdec->buf[1] = dat;
		mdec->phase = 3;
		return 0;
	}
	if (mdec->phase == 3) {
		/* 等待读取鼠标第三字节 */
		mdec->buf[2] = dat;
		mdec->phase = 1;

		mdec->phase = 1;
		mdec->btn = mdec->buf[0] & 0x07;
		mdec->x = mdec->buf[1];
		mdec->y = mdec->buf[2];
		if((mdec->buf[0] & 0x10) != 0) {
			mdec->x |= 0xffffff00;
		}
		if((mdec->buf[0] & 0x20) != 0) {
			mdec->y |= 0xffffff00;
		}
		mdec->y = - mdec->y;	/* 鼠标的y方向与画面符号相反 */
		return 1;
	}
	return -1; /* error的情况 */
}

最后一步就是修改 HariMain 中的for循环完成显示

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
for (;;) {
		io_cli();
		if(fifo8_status(&keyfifo) + fifo8_status(&mousefifo) == 0) {
			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();
				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[1] = 'R';
					}
					if((mdec.btn & 0x04) != 0) {
						s[1] = 'C';
					}
					boxfill8(binfo->vram, binfo->scrnx, COL8_008484, 32, 16, 32+15*8-1, 31);
					putfonts8_asc(binfo->vram, binfo->scrnx, 32, 16, COL8_FFFFFF, s);
					/* 鼠标指针的移动 */
					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 - 16) {
						mx = binfo->scrnx - 16;
					}
					if (my > binfo->scrny - 16) {
						my = binfo->scrny - 16;
					}
					sprintf(s, "(%3d, %3d)", mx, my);
					boxfill8(binfo->vram, binfo->scrnx, COL8_008484, 0, 0, 79, 15); /* 隐藏坐标 */
					putfonts8_asc(binfo->vram, binfo->scrnx, 0, 0, COL8_FFFFFF, s); /* 显示坐标 */
					putblock8_8(binfo->vram, binfo->scrnx, 16, 16, mx, my, mcursor, 16); /* 描画鼠标 */
				}
			}
		}
}

​ 大功告成！

7

8

点击左键的时候变成 Lcr ，点击右键就是 Rcr ，点击滚轮就是 Ccr