Showing the changes to gui-fbdev/fbdev.c (1 of 27 files). Show all
Unified · Split
| @@ -0,0 +1,673 @@ | |||
| 1 | #include "u.h" | ||
| 2 | #include "lib.h" | ||
| 3 | #include "dat.h" | ||
| 4 | #include "fns.h" | ||
| 5 | #include "error.h" | ||
| 6 | |||
| 7 | #include <draw.h> | ||
| 8 | #include <memdraw.h> | ||
| 9 | #include <keyboard.h> | ||
| 10 | #include <cursor.h> | ||
| 11 | #include "screen.h" | ||
| 12 | |||
| 13 | #undef long | ||
| 14 | #undef ulong | ||
| 15 | |||
| 16 | #include <linux/fb.h> | ||
| 17 | #include <linux/input.h> | ||
| 18 | |||
| 19 | uchar* fbp; | ||
| 20 | Memimage* screenimage; | ||
| 21 | Memimage* backbuf; | ||
| 22 | Rectangle screenr; | ||
| 23 | char* snarfbuf; | ||
| 24 | struct fb_fix_screeninfo finfo; | ||
| 25 | struct fb_var_screeninfo vinfo; | ||
| 26 | int *eventfds = NULL; | ||
| 27 | int neventfds; | ||
| 28 | Point mousexy; | ||
| 29 | char shift_state; | ||
| 30 | int ttyfd; | ||
| 31 | char* tty; | ||
| 32 | char hidden; | ||
| 33 | int devicesfd; | ||
| 34 | ulong chan; | ||
| 35 | int depth; | ||
| 36 | |||
| 37 | #include <sys/ioctl.h> | ||
| 38 | #include <sys/mman.h> | ||
| 39 | #include <limits.h> | ||
| 40 | |||
| 41 | #include <fcntl.h> | ||
| 42 | #include <termios.h> | ||
| 43 | #include <poll.h> | ||
| 44 | #include <sys/ioctl.h> | ||
| 45 | #include <linux/keyboard.h> | ||
| 46 | #include <signal.h> | ||
| 47 | |||
| 48 | #include <termios.h> | ||
| 49 | |||
| 50 | #define ulong p9_ulong | ||
| 51 | |||
| 52 | int code2key[] = { | ||
| 53 | Kesc, '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '-', '=', '\x08', | ||
| 54 | '\x09', 'q', 'w', 'e', 'r', 't', 'y', 'u', 'i', 'o', 'p', '[', ']', '\n', | ||
| 55 | Kctl, 'a', 's', 'd', 'f', 'g', 'h', 'j', 'k', 'l', ';', '\'', '`', Kshift, | ||
| 56 | '\\', 'z', 'x', 'c', 'v', 'b', 'n', 'm', ',', '.', '/', Kshift, '*', Kalt, | ||
| 57 | ' ', Kcaps, KF|1, KF|2, KF|3, KF|4, KF|5, KF|6, KF|7, KF|8, KF|9, KF|10, | ||
| 58 | Knum, Kscroll, | ||
| 59 | '7', '8', '9', '-', '4', '5', '6', '+', '1', '2', '3', '0', '.', | ||
| 60 | }; | ||
| 61 | |||
| 62 | int code2key_shift[] = { | ||
| 63 | Kesc, '!', '@', '#', '$', '%', '^', '&', '*', '(', ')', '_', '+', '\x08', | ||
| 64 | '\x09', 'Q', 'W', 'E', 'R', 'T', 'Y', 'U', 'I', 'O', 'P', '{', '}', '\n', | ||
| 65 | Kctl, 'A', 'S', 'D', 'F', 'G', 'H', 'J', 'K', 'L', ':', '\"', '~', Kshift, | ||
| 66 | '|', 'Z', 'X', 'C', 'V', 'B', 'N', 'M', '<', '>', '?', Kshift, '*', Kalt, | ||
| 67 | ' ', Kcaps, KF|1, KF|2, KF|3, KF|4, KF|5, KF|6, KF|7, KF|8, KF|9, KF|10, | ||
| 68 | Knum, Kscroll, | ||
| 69 | '7', '8', '9', '-', '4', '5', '6', '+', '1', '2', '3', '0', '.', | ||
| 70 | }; | ||
| 71 | |||
| 72 | Memimage *gscreen; | ||
| 73 | char *snarfbuf = nil; | ||
| 74 | |||
| 75 | int onevent(struct input_event*); | ||
| 76 | void termctl(uint32_t o, int or); | ||
| 77 | void ctrlc(int sig); | ||
| 78 | |||
| 79 | void | ||
| 80 | _fbput(Memimage *m, Rectangle r) { | ||
| 81 | int y; | ||
| 82 | |||
| 83 | for (y = r.min.y; y < r.max.y; y++){ | ||
| 84 | long loc = y * finfo.line_length + r.min.x * depth; | ||
| 85 | void *ptr = m->data->bdata + y * m->width * 4 + r.min.x * depth; | ||
| 86 | |||
| 87 | memcpy(fbp + loc, ptr, Dx(r) * depth); | ||
| 88 | } | ||
| 89 | } | ||
| 90 | |||
| 91 | Memimage* | ||
| 92 | fbattach(int fbdevidx) | ||
| 93 | { | ||
| 94 | Rectangle r; | ||
| 95 | char devname[64]; | ||
| 96 | size_t size; | ||
| 97 | int fd; | ||
| 98 | |||
| 99 | /* | ||
| 100 | * Connect to /dev/fb0 | ||
| 101 | */ | ||
| 102 | snprintf(devname, sizeof(devname) - 1, "/dev/fb%d", fbdevidx); | ||
| 103 | if ((fd = open(devname, O_RDWR)) < 0) | ||
| 104 | goto err; | ||
| 105 | |||
| 106 | if (ioctl(fd, FBIOGET_VSCREENINFO, &(vinfo)) < 0) | ||
| 107 | goto err; | ||
| 108 | |||
| 109 | switch (vinfo.bits_per_pixel) { | ||
| 110 | case 32: | ||
| 111 | chan = XRGB32; | ||
| 112 | depth = 4; | ||
| 113 | break; | ||
| 114 | case 16: | ||
| 115 | chan = RGB16; | ||
| 116 | depth = 2; | ||
| 117 | break; | ||
| 118 | default: | ||
| 119 | goto err; | ||
| 120 | } | ||
| 121 | |||
| 122 | if (ioctl(fd, FBIOGET_FSCREENINFO, &(finfo)) < 0) | ||
| 123 | goto err; | ||
| 124 | |||
| 125 | size = vinfo.yres_virtual * finfo.line_length; | ||
| 126 | if ((fbp = mmap(0, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, (off_t)0)) < 0) | ||
| 127 | goto err; | ||
| 128 | /* | ||
| 129 | * Figure out underlying screen format. | ||
| 130 | */ | ||
| 131 | r = Rect(0, 0, vinfo.xres_virtual, vinfo.yres_virtual); | ||
| 132 | |||
| 133 | screenr = r; | ||
| 134 | |||
| 135 | screenimage = allocmemimage(r, chan); | ||
| 136 | backbuf = allocmemimage(r, chan); | ||
| 137 | return backbuf; | ||
| 138 | |||
| 139 | err: | ||
| 140 | return nil; | ||
| 141 | } | ||
| 142 | |||
| 143 | int | ||
| 144 | eventattach() | ||
| 145 | { | ||
| 146 | char eventfile[PATH_MAX] = ""; | ||
| 147 | char line[PATH_MAX]; | ||
| 148 | FILE *devices; | ||
| 149 | char *ptr; | ||
| 150 | |||
| 151 | neventfds = 0; | ||
| 152 | devices = fopen("/proc/bus/input/devices", "r"); | ||
| 153 | if (devices == NULL) | ||
| 154 | return -1; | ||
| 155 | while (fgets(line, sizeof(line)-1, devices) != NULL) | ||
| 156 | if (line[0] == 'H') { | ||
| 157 | ptr = strstr(line, "event"); | ||
| 158 | if (ptr == NULL) | ||
| 159 | continue; | ||
| 160 | ptr[strcspn(ptr, " \r\n")] = '\0'; | ||
| 161 | snprintf(eventfile, sizeof(eventfile)-1, "/dev/input/%s", ptr); | ||
| 162 | neventfds++; | ||
| 163 | eventfds = realloc(eventfds, neventfds * sizeof(int)); | ||
| 164 | eventfds[neventfds-1] = open(eventfile, O_RDONLY); | ||
| 165 | if (eventfds[neventfds-1] < 0) | ||
| 166 | neventfds--; | ||
| 167 | } | ||
| 168 | fclose(devices); | ||
| 169 | |||
| 170 | if (neventfds == 0) | ||
| 171 | return -1; | ||
| 172 | return 1; | ||
| 173 | } | ||
| 174 | |||
| 175 | void | ||
| 176 | flushmemscreen(Rectangle r) | ||
| 177 | { | ||
| 178 | int x, y, i; | ||
| 179 | Point p; | ||
| 180 | long fbloc; | ||
| 181 | int x2, y2; | ||
| 182 | |||
| 183 | if (rectclip(&r, screenimage->r) == 0) | ||
| 184 | return; | ||
| 185 | if (Dx(r) == 0 || Dy(r) == 0) | ||
| 186 | return; | ||
| 187 | |||
| 188 | assert(!canqlock(&drawlock)); | ||
| 189 | |||
| 190 | memimagedraw(screenimage, r, backbuf, r.min, nil, r.min, S); | ||
| 191 | |||
| 192 | if (hidden != 0) | ||
| 193 | return; | ||
| 194 | |||
| 195 | p = mousexy; | ||
| 196 | |||
| 197 | // draw cursor | ||
| 198 | for (x = 0; x < 16; x++) { | ||
| 199 | x2 = x + cursor.offset.x; | ||
| 200 | |||
| 201 | if ((p.x + x2) < 0) | ||
| 202 | continue; | ||
| 203 | |||
| 204 | if ((p.x + x2) >= screenimage->r.max.x) | ||
| 205 | break; | ||
| 206 | |||
| 207 | for (y = 0; y < 16; y++) { | ||
| 208 | y2 = y + cursor.offset.y; | ||
| 209 | |||
| 210 | if ((p.y + y2) < 0) | ||
| 211 | continue; | ||
| 212 | |||
| 213 | if ((p.y + y2) >= screenimage->r.max.y) | ||
| 214 | break; | ||
| 215 | |||
| 216 | i = y * 2 + x / 8; | ||
| 217 | fbloc = ((p.y+y2) * screenimage->r.max.x + (p.x+x2)) * depth; | ||
| 218 | |||
| 219 | if (cursor.clr[i] & (128 >> (x % 8))) { | ||
| 220 | switch (depth) { | ||
| 221 | case 2: | ||
| 222 | *((uint16_t*)(screenimage->data->bdata + fbloc)) = 0xFFFF; | ||
| 223 | break; | ||
| 224 | case 4: | ||
| 225 | *((uint32_t*)(screenimage->data->bdata + fbloc)) = 0xFFFFFFFF; | ||
| 226 | break; | ||
| 227 | } | ||
| 228 | } | ||
| 229 | |||
| 230 | if (cursor.set[i] & (128 >> (x % 8))) { | ||
| 231 | switch (depth) { | ||
| 232 | case 2: | ||
| 233 | *((uint16_t*)(screenimage->data->bdata + fbloc)) = 0x0000; | ||
| 234 | break; | ||
| 235 | case 4: | ||
| 236 | *((uint32_t*)(screenimage->data->bdata + fbloc)) = 0xFF000000; | ||
| 237 | break; | ||
| 238 | } | ||
| 239 | } | ||
| 240 | } | ||
| 241 | } | ||
| 242 | |||
| 243 | _fbput(screenimage, r); | ||
| 244 | } | ||
| 245 | |||
| 246 | static void | ||
| 247 | fbproc(void *v) | ||
| 248 | { | ||
| 249 | struct input_event data; | ||
| 250 | char buf[32]; | ||
| 251 | struct pollfd *pfd; | ||
| 252 | int r; | ||
| 253 | int ioctlarg; | ||
| 254 | |||
| 255 | pfd = calloc(3, sizeof(struct pollfd)); | ||
| 256 | pfd[0].fd = ttyfd; // for virtual console switches | ||
| 257 | pfd[0].events = POLLPRI; | ||
| 258 | pfd[1].fd = 0; // stdin goes to nowhere | ||
| 259 | pfd[1].events = POLLIN; | ||
| 260 | pfd[2].fd = open("/proc/bus/input/devices", O_RDONLY); // input hotplug | ||
| 261 | if (pfd[2].fd < 0) | ||
| 262 | panic("cannot open /proc/bus/input/devices: %r"); | ||
| 263 | pfd[2].events = POLLIN; | ||
| 264 | |||
| 265 | TOP: | ||
| 266 | while(read(pfd[2].fd, buf, 31) > 0); | ||
| 267 | |||
| 268 | pfd = realloc(pfd, sizeof(struct pollfd) * (neventfds + 3)); | ||
| 269 | for (r = 0; r < neventfds; r++) { | ||
| 270 | pfd[r+3].fd = eventfds[r]; | ||
| 271 | pfd[r+3].events = POLLIN; | ||
| 272 | } | ||
| 273 | |||
| 274 | for(;;) { | ||
| 275 | shift_state = 6; | ||
| 276 | if (ioctl(0, TIOCLINUX, &shift_state) < 0) | ||
| 277 | panic("ioctl TIOCLINUX 6: %r"); | ||
| 278 | |||
| 279 | r = poll(pfd, 3+neventfds, -1); | ||
| 280 | if (r < 0) | ||
| 281 | oserror(); | ||
| 282 | if (pfd[0].revents & POLLPRI) { | ||
| 283 | if ((r = read(ttyfd, buf, 31)) <= 0) | ||
| 284 | panic("ttyfd read: %r"); | ||
| 285 | buf[r] = '\0'; | ||
| 286 | if (strcmp(buf, tty) == 0) { | ||
| 287 | hidden = 0; | ||
| 288 | printf("\e[?25l"); | ||
| 289 | fflush(stdout); | ||
| 290 | qlock(&drawlock); | ||
| 291 | flushmemscreen(gscreen->clipr); | ||
| 292 | qunlock(&drawlock); | ||
| 293 | } | ||
| 294 | else | ||
| 295 | hidden = 1; | ||
| 296 | close(ttyfd); | ||
| 297 | ttyfd = open("/sys/class/tty/tty0/active", O_RDONLY); | ||
| 298 | if (ttyfd < 0) | ||
| 299 | panic("cannot open tty active fd: %r"); | ||
| 300 | pfd[0].fd = ttyfd; | ||
| 301 | read(ttyfd, buf, 0); | ||
| 302 | } | ||
| 303 | if (pfd[1].revents & POLLIN) | ||
| 304 | read(pfd[1].fd, buf, 31); | ||
| 305 | if (pfd[2].revents & POLLIN) { | ||
| 306 | for (r = 0; r < neventfds; r++) | ||
| 307 | close(eventfds[r]); | ||
| 308 | if(eventattach() < 0) { | ||
| 309 | panic("cannot open event files: %r"); | ||
| 310 | } | ||
| 311 | goto TOP; | ||
| 312 | } | ||
| 313 | for (r = 0; r < neventfds; r++) | ||
| 314 | if (pfd[r+3].revents & POLLIN) { | ||
| 315 | if (read(pfd[r+3].fd, &data, sizeof(data)) != sizeof(data)) | ||
| 316 | panic("eventfd read: %r"); | ||
| 317 | if (onevent(&data) == 0) { | ||
| 318 | ioctlarg = 15; | ||
| 319 | if (ioctl(0, TIOCLINUX, &ioctlarg) != 0) { | ||
| 320 | ioctlarg = 4; | ||
| 321 | ioctl(0, TIOCLINUX, &ioctlarg); | ||
| 322 | qlock(&drawlock); | ||
| 323 | flushmemscreen(gscreen->clipr); | ||
| 324 | qunlock(&drawlock); | ||
| 325 | } else { | ||
| 326 | write(1, "\033[9;30]", 7); | ||
| 327 | } | ||
| 328 | } | ||
| 329 | } | ||
| 330 | } | ||
| 331 | |||
| 332 | printf("\e[?25h"); | ||
| 333 | fflush(stdout); | ||
| 334 | termctl(ECHO, 1); | ||
| 335 | free(pfd); | ||
| 336 | } | ||
| 337 | |||
| 338 | void | ||
| 339 | screensize(Rectangle r, ulong chan) | ||
| 340 | { | ||
| 341 | gscreen = backbuf; | ||
| 342 | gscreen->clipr = ZR; | ||
| 343 | } | ||
| 344 | |||
| 345 | void | ||
| 346 | screeninit(void) | ||
| 347 | { | ||
| 348 | int r; | ||
| 349 | char buf[1]; | ||
| 350 | |||
| 351 | // set up terminal | ||
| 352 | printf("\e[?25l"); | ||
| 353 | fflush(stdout); | ||
| 354 | termctl(~(ICANON|ECHO), 0); | ||
| 355 | signal(SIGINT, ctrlc); | ||
| 356 | |||
| 357 | memimageinit(); | ||
| 358 | |||
| 359 | // tty switching | ||
| 360 | ttyfd = open("/sys/class/tty/tty0/active", O_RDONLY); | ||
| 361 | if (ttyfd >= 0) { | ||
| 362 | tty = malloc(32); | ||
| 363 | r = read(ttyfd, tty, 31); | ||
| 364 | if (r >= 0) | ||
| 365 | tty[r] = '\0'; | ||
| 366 | else | ||
| 367 | tty[0] = '\0'; | ||
| 368 | close(ttyfd); | ||
| 369 | ttyfd = open("/sys/class/tty/tty0/active", O_RDONLY); | ||
| 370 | } | ||
| 371 | if (ttyfd < 0) | ||
| 372 | panic("cannot open tty active fd: %r"); | ||
| 373 | read(ttyfd, buf, 0); | ||
| 374 | hidden = 0; | ||
| 375 | |||
| 376 | if(fbattach(0) == nil) { | ||
| 377 | panic("cannot open framebuffer: %r"); | ||
| 378 | } | ||
| 379 | |||
| 380 | if(eventattach() < 0) { | ||
| 381 | panic("cannot open event files: %r"); | ||
| 382 | } | ||
| 383 | |||
| 384 | screensize(screenr, chan); | ||
| 385 | if (gscreen == nil) | ||
| 386 | panic("screensize failed"); | ||
| 387 | |||
| 388 | gscreen->clipr = screenr; | ||
| 389 | kproc("fbdev", fbproc, nil); | ||
| 390 | |||
| 391 | terminit(); | ||
| 392 | |||
| 393 | qlock(&drawlock); | ||
| 394 | flushmemscreen(gscreen->clipr); | ||
| 395 | qunlock(&drawlock); | ||
| 396 | } | ||
| 397 | |||
| 398 | Memdata* | ||
| 399 | attachscreen(Rectangle *r, ulong *chan, int *depth, int *width, int *softscreen) | ||
| 400 | { | ||
| 401 | *r = gscreen->clipr; | ||
| 402 | *chan = gscreen->chan; | ||
| 403 | *depth = gscreen->depth; | ||
| 404 | *width = gscreen->width; | ||
| 405 | *softscreen = 1; | ||
| 406 | |||
| 407 | gscreen->data->ref++; | ||
| 408 | return gscreen->data; | ||
| 409 | } | ||
| 410 | |||
| 411 | void | ||
| 412 | getcolor(ulong i, ulong *r, ulong *g, ulong *b) | ||
| 413 | { | ||
| 414 | ulong v; | ||
| 415 | |||
| 416 | v = cmap2rgb(i); | ||
| 417 | *r = (v>>16)&0xFF; | ||
| 418 | *g = (v>>8)&0xFF; | ||
| 419 | *b = v&0xFF; | ||
| 420 | } | ||
| 421 | |||
| 422 | void | ||
| 423 | setcolor(ulong i, ulong r, ulong g, ulong b) | ||
| 424 | { | ||
| 425 | /* no-op */ | ||
| 426 | return; | ||
| 427 | } | ||
| 428 | |||
| 429 | char* | ||
| 430 | clipread(void) | ||
| 431 | { | ||
| 432 | if(snarfbuf) | ||
| 433 | return strdup(snarfbuf); | ||
| 434 | return nil; | ||
| 435 | } | ||
| 436 | |||
| 437 | int | ||
| 438 | clipwrite(char *buf) | ||
| 439 | { | ||
| 440 | if(snarfbuf) | ||
| 441 | free(snarfbuf); | ||
| 442 | snarfbuf = strdup(buf); | ||
| 443 | return 0; | ||
| 444 | } | ||
| 445 | |||
| 446 | void | ||
| 447 | guimain(void) | ||
| 448 | { | ||
| 449 | cpubody(); | ||
| 450 | } | ||
| 451 | |||
| 452 | void | ||
| 453 | termctl(uint32_t o, int or) | ||
| 454 | { | ||
| 455 | struct termios t; | ||
| 456 | |||
| 457 | tcgetattr(0, &t); | ||
| 458 | if (or) | ||
| 459 | t.c_lflag |= o; | ||
| 460 | else | ||
| 461 | t.c_lflag &= o; | ||
| 462 | tcsetattr(0, TCSANOW, &t); | ||
| 463 | } | ||
| 464 | |||
| 465 | void | ||
| 466 | ctrlc(int sig) { | ||
| 467 | } | ||
| 468 | |||
| 469 | int | ||
| 470 | onevent(struct input_event *data) | ||
| 471 | { | ||
| 472 | Rectangle old, new; | ||
| 473 | ulong msec; | ||
| 474 | static int buttons; | ||
| 475 | static Point coord; | ||
| 476 | static char touched; | ||
| 477 | static Point startmousept; | ||
| 478 | static Point startpt; | ||
| 479 | int key; | ||
| 480 | static ulong lastmsec = 0; | ||
| 481 | |||
| 482 | if (hidden != 0) | ||
| 483 | return -1; | ||
| 484 | |||
| 485 | msec = ticks(); | ||
| 486 | |||
| 487 | old.min = mousexy; | ||
| 488 | old.max = addpt(old.min, Pt(16, 16)); | ||
| 489 | |||
| 490 | buttons &= ~0x18; | ||
| 491 | |||
| 492 | switch(data->type) { | ||
| 493 | case 3: | ||
| 494 | switch(data->code) { | ||
| 495 | case 0: | ||
| 496 | coord.x = data->value; | ||
| 497 | break; | ||
| 498 | case 1: | ||
| 499 | coord.y = data->value; | ||
| 500 | break; | ||
| 501 | case 0x18: | ||
| 502 | case 0x1c: | ||
| 503 | if (data->value == 0) | ||
| 504 | touched = 0; | ||
| 505 | else if (data->value > 24) { | ||
| 506 | touched = 1; | ||
| 507 | startmousept = coord; | ||
| 508 | startpt = mousexy; | ||
| 509 | } | ||
| 510 | break; | ||
| 511 | default: | ||
| 512 | return -1; | ||
| 513 | } | ||
| 514 | if (touched) | ||
| 515 | mousexy = addpt(startpt, divpt(subpt(coord, startmousept), 4)); | ||
| 516 | break; | ||
| 517 | case 2: | ||
| 518 | switch(data->code) { | ||
| 519 | case 0: | ||
| 520 | mousexy.x += data->value; | ||
| 521 | break; | ||
| 522 | case 1: | ||
| 523 | mousexy.y += data->value; | ||
| 524 | break; | ||
| 525 | case 8: | ||
| 526 | buttons |= data->value == 1? 8: 16; | ||
| 527 | break; | ||
| 528 | default: | ||
| 529 | return -1; | ||
| 530 | } | ||
| 531 | break; | ||
| 532 | case 1: | ||
| 533 | switch(data->code) { | ||
| 534 | case 0x110: | ||
| 535 | if (data->value == 1) | ||
| 536 | buttons |= 1; | ||
| 537 | else | ||
| 538 | buttons &= ~1; | ||
| 539 | break; | ||
| 540 | case 0x111: | ||
| 541 | if (data->value == 1) | ||
| 542 | buttons |= shift_state & (1 << KG_SHIFT)? 2: 4; | ||
| 543 | else | ||
| 544 | buttons &= ~(shift_state & (1 << KG_SHIFT)? 2: 4); | ||
| 545 | break; | ||
| 546 | case 0x112: | ||
| 547 | if (data->value == 1) | ||
| 548 | buttons |= 2; | ||
| 549 | else | ||
| 550 | buttons &= ~2; | ||
| 551 | break; | ||
| 552 | default: | ||
| 553 | if (hidden) | ||
| 554 | return 0; | ||
| 555 | if (data->code > 0 && data->code <= nelem(code2key)) { | ||
| 556 | if (shift_state & (1 << KG_SHIFT)) | ||
| 557 | key = code2key_shift[data->code-1]; | ||
| 558 | else | ||
| 559 | key = code2key[data->code-1]; | ||
| 560 | if (key == Kshift) | ||
| 561 | return -1; | ||
| 562 | kbdkey(key, data->value); | ||
| 563 | return 0; | ||
| 564 | } | ||
| 565 | switch(data->code) { | ||
| 566 | case 87: | ||
| 567 | kbdkey(KF|11, data->value); | ||
| 568 | break; | ||
| 569 | case 88: | ||
| 570 | kbdkey(KF|12, data->value); | ||
| 571 | break; | ||
| 572 | case 96: | ||
| 573 | kbdkey('\n', data->value); | ||
| 574 | break; | ||
| 575 | case 97: | ||
| 576 | kbdkey(Kctl, data->value); | ||
| 577 | break; | ||
| 578 | case 98: | ||
| 579 | kbdkey('/', data->value); | ||
| 580 | break; | ||
| 581 | case 100: | ||
| 582 | kbdkey(Kalt, data->value); | ||
| 583 | break; | ||
| 584 | case 102: | ||
| 585 | kbdkey(Khome, data->value); | ||
| 586 | break; | ||
| 587 | case 103: | ||
| 588 | kbdkey(Kup, data->value); | ||
| 589 | break; | ||
| 590 | case 104: | ||
| 591 | kbdkey(Kpgup, data->value); | ||
| 592 | break; | ||
| 593 | case 105: | ||
| 594 | kbdkey(Kleft, data->value); | ||
| 595 | break; | ||
| 596 | case 106: | ||
| 597 | kbdkey(Kright, data->value); | ||
| 598 | break; | ||
| 599 | case 107: | ||
| 600 | kbdkey(Kend, data->value); | ||
| 601 | break; | ||
| 602 | case 108: | ||
| 603 | kbdkey(Kdown, data->value); | ||
| 604 | break; | ||
| 605 | case 109: | ||
| 606 | kbdkey(Kpgdown, data->value); | ||
| 607 | break; | ||
| 608 | case 110: | ||
| 609 | kbdkey(Kins, data->value); | ||
| 610 | break; | ||
| 611 | case 111: | ||
| 612 | kbdkey(Kdel, data->value); | ||
| 613 | break; | ||
| 614 | } | ||
| 615 | return 0; | ||
| 616 | } | ||
| 617 | break; | ||
| 618 | default: | ||
| 619 | return -1; | ||
| 620 | } | ||
| 621 | |||
| 622 | if (mousexy.x < screenimage->r.min.x) | ||
| 623 | mousexy.x = screenimage->r.min.x; | ||
| 624 | if (mousexy.y < screenimage->r.min.y) | ||
| 625 | mousexy.y = screenimage->r.min.y; | ||
| 626 | if (mousexy.x > screenimage->r.max.x) | ||
| 627 | mousexy.x = screenimage->r.max.x; | ||
| 628 | if (mousexy.y > screenimage->r.max.y) | ||
| 629 | mousexy.y = screenimage->r.max.y; | ||
| 630 | |||
| 631 | new.min = mousexy; | ||
| 632 | new.max = addpt(new.min, Pt(16, 16)); // size of cursor bitmap | ||
| 633 | |||
| 634 | combinerect(&new, old); | ||
| 635 | new.min = subpt(new.min, Pt(16, 16)); // to encompass any cursor->offset | ||
| 636 | |||
| 637 | qlock(&drawlock); | ||
| 638 | flushmemscreen(new); | ||
| 639 | qunlock(&drawlock); | ||
| 640 | |||
| 641 | if ((msec - lastmsec) < 10) | ||
| 642 | if (data->type != 1) | ||
| 643 | return 0; | ||
| 644 | |||
| 645 | lastmsec = msec; | ||
| 646 | |||
| 647 | absmousetrack(mousexy.x, mousexy.y, buttons, msec); | ||
| 648 | |||
| 649 | return 0; | ||
| 650 | } | ||
| 651 | |||
| 652 | void | ||
| 653 | mouseset(Point p) | ||
| 654 | { | ||
| 655 | qlock(&drawlock); | ||
| 656 | mousexy = p; | ||
| 657 | flushmemscreen(screenr); | ||
| 658 | qunlock(&drawlock); | ||
| 659 | } | ||
| 660 | |||
| 661 | void | ||
| 662 | setcursor(void) | ||
| 663 | { | ||
| 664 | qlock(&drawlock); | ||
| 665 | flushmemscreen(screenr); | ||
| 666 | qunlock(&drawlock); | ||
| 667 | } | ||
| 668 | |||
| 669 | void | ||
| 670 | titlewrite(char* buf) | ||
| 671 | { | ||
| 672 | } | ||
| 673 | |||