home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / pc / ABUSESRC.ZIP / AbuseSrc / imlib / port / svga / event.c next >
Encoding:
C/C++ Source or Header  |  1997-07-07  |  8.3 KB  |  302 lines
  1. #include "system.h"
  2. #include "image.hpp"
  3. #include "palette.hpp"
  4. #include "mdlread.hpp"
  5. #include "video.hpp"
  6. #include "dos.h"
  7. #include "gifread.hpp"
  8. #include "macs.hpp"
  9. #include "mouse.hpp"
  10. #include "event.hpp"
  11. #include "sprite.hpp"
  12. #include "monoprnt.hpp"
  13. #include "dprint.hpp"
  14. #include <fcntl.h>
  15. #include <sys/types.h>
  16. #include <sys/time.h>
  17. #include <stdlib.h>
  18. #include <stdio.h>
  19. #include "keys.hpp"
  20. #include <stdio.h>
  21. #include <unistd.h>
  22. #include <getopt.h>
  23. #include <signal.h>
  24. #include <termios.h>
  25. #include <linux/kd.h>
  26. #include <linux/vt.h>
  27. #include <linux/keyboard.h>
  28. #include <sys/ioctl.h>
  29. #include <sys/stat.h>
  30. #undef EGA
  31. #include <vga.h>
  32.  
  33.  
  34. int console_fd;
  35.  
  36. void event_handler::flush_screen()
  37. {
  38.   mouse->mouse_sprite()->x=mouse->drawx();
  39.   mouse->mouse_sprite()->y=mouse->drawy();
  40.   mouse->mouse_sprite()->get_background();
  41.   mouse->mouse_sprite()->draw();
  42.   update_dirty(screen);
  43.   mouse->mouse_sprite()->restore_background();
  44. }
  45.  
  46. int event_handler::get_key_flags()
  47. {
  48.   return 0;
  49. }
  50.  
  51. int shift;
  52.  
  53. int fd_ready_to_read(int fd)
  54. {
  55.   struct timeval tv={0,0};
  56.   fd_set kbd_set;
  57.   FD_ZERO(&kbd_set);
  58.   FD_SET(fd,&kbd_set);
  59.   select(FD_SETSIZE,&kbd_set,NULL,NULL,&tv);
  60.   return (FD_ISSET(fd,&kbd_set));
  61. }
  62.  
  63.  
  64. int key_waiting()
  65. {
  66.   return fd_ready_to_read(console_fd);
  67. }
  68.  
  69. int con_translate(int ch)
  70. {
  71.   int up=(!(ch&0x80)),key=ch&0x7f;
  72.   if (key==42 || key==54)
  73.     shift=up;
  74.    
  75.   switch (key)
  76.   {
  77.     case 73 : ch=JK_PAGEUP;                       break;
  78.     case 81 : ch=JK_PAGEDOWN;                     break;
  79.     case 42 : ch=JK_SHIFT_L;                      break;
  80.     case 54 : ch=JK_SHIFT_R;                      break;
  81.     case 72 : ch=JK_UP;                           break;
  82.     case 80 : ch=JK_DOWN;                         break;
  83.     case 82 : ch=JK_INSERT;                       break;
  84.     case 75 : ch=JK_LEFT;                         break;
  85.     case 77 : ch=JK_RIGHT;                        break;
  86.     case 29 : ch=JK_CTRL_L;                       break;
  87.     case 56 : ch=JK_ALT_L;                        break;
  88.     case 58 : ch=JK_CAPS;                         break;
  89.     case 69 : ch=JK_NUM_LOCK;                     break;
  90.     case 71 : ch=JK_HOME;                         break;
  91.     case 79 : ch=JK_END;                          break;
  92.     case 83 : ch=JK_DEL;                          break;
  93.     case 57 : ch=JK_SPACE;                        break;
  94.     case 1  : ch=JK_ESC;                          break;
  95.     case 28  : ch=JK_ENTER;                       break;
  96.     case 15  : ch=JK_TAB;                         break;
  97.     case 14  : ch=JK_BACKSPACE;                   break;
  98.     case 2  :  ch=shift ? '!' : '1';                break;
  99.     case 3  :  ch=shift ? '@' : '2';                break;
  100.     case 4  :  ch=shift ? '#' : '3';                break;
  101.     case 5  :  ch=shift ? '$' : '4';                break;
  102.     case 6  :  ch=shift ? '%' : '5';                break;
  103.     case 7  :  ch=shift ? '^' : '6';                break;
  104.     case 8  :  ch=shift ? '&' : '7';                break;
  105.     case 9  :  ch=shift ? '*' : '8';                break;
  106.     case 10  :  ch=shift ? '(' : '9';                break;
  107.     case 11  :  ch=shift ? ')' : '0';                break;
  108.     case 12  :  ch=shift ? '_' : '-';                break;
  109.     case 13  :  ch=shift ? '+' : '=';                break;
  110.     case 41  :  ch=shift ? '~' : '`';                break;
  111.     case 26  :  ch=shift ? '{' : '[';                break;
  112.     case 27  :  ch=shift ? '}' : ']';                break;
  113.     case 39  :  ch=shift ? ':' : ';';                break;
  114.     case 40  :  ch=shift ? '"' : '\'';               break;
  115.     case 51  :  ch=shift ? '<' : ',';                break;
  116.     case 52  :  ch=shift ? '>' : '.';                break;
  117.     case 53  :  ch=shift ? '?' : '/';                break;
  118.     case 43  :  ch=shift ? '|' : '\\';               break;
  119.     case 59 :  ch=JK_F1;                             break; 
  120.     case 60 :  ch=JK_F2;                             break; 
  121.     case 61 :  ch=JK_F3;                             break; 
  122.     case 62 :  ch=JK_F4;                             break; 
  123.     case 63 :  ch=JK_F5;                             break; 
  124.     case 64 :  ch=JK_F6;                             break; 
  125.     case 65 :  ch=JK_F7;                             break; 
  126.     case 66 :  ch=JK_F8;                             break; 
  127.     case 67 :  ch=JK_F9;                             break; 
  128.     case 68 :  ch=JK_F10;                            break; 
  129.  
  130.     default :
  131.       switch (key)
  132.       {
  133.         case 30 : ch='a';       break;
  134.         case 48 : ch='b';       break;
  135.         case 46 : ch='c';       break;
  136.         case 32 : ch='d';       break;
  137.         case 18 : ch='e';       break;
  138.         case 33 : ch='f';       break;
  139.         case 34 : ch='g';       break;
  140.         case 35 : ch='h';       break;
  141.         case 23 : ch='i';       break;
  142.         case 36 : ch='j';       break;
  143.         case 37 : ch='k';       break;
  144.         case 38 : ch='l';       break;
  145.         case 50 : ch='m';       break;
  146.         case 49 : ch='n';       break;
  147.         case 24 : ch='o';       break;
  148.         case 25 : ch='p';       break;
  149.         case 16 : ch='q';       break;
  150.         case 19 : ch='r';       break;
  151.  
  152.         case 31 : ch='s';       break;
  153.         case 20 : ch='t';       break;
  154.         case 22 : ch='u';       break;
  155.         case 47 : ch='v';       break;
  156.         case 17 : ch='w';       break;
  157.         case 45 : ch='x';       break;
  158.         case 21 : ch='y';       break;
  159.         case 44 : ch='z';       break;
  160.         default : ch=0;       break;
  161.       }
  162.       if (shift) ch-=('a'-'A');
  163.   }
  164.   return ch;
  165. }
  166.  
  167.  
  168.  
  169. int event_handler::event_waiting()
  170. {
  171.   int ch;
  172.   unsigned char c;
  173.   event *ev;
  174.   if (ewaiting) return 1;
  175.   
  176.   if (key_waiting()) 
  177.   {
  178.     read(console_fd,&c,1);
  179.     ch=con_translate(c);
  180.     ewaiting=1;
  181.  
  182.     ev=new event;
  183.     if (c&0x80)
  184.       ev->type=EV_KEYRELEASE;
  185.     else
  186.       ev->type=EV_KEY;
  187.     ev->key=ch;
  188.     events.add_end((linked_node *)ev);
  189.     last_key=ch;
  190.  
  191.   }
  192.   else if (mhere)
  193.   {
  194.     mouse->update();
  195.     if (mouse->lastx()!=mouse->x() || mouse->lasty()!=mouse->y()
  196.        || mouse->last_button()!=mouse->button())
  197.       ewaiting=1;
  198.   }
  199.   return ewaiting;
  200. }
  201.  
  202.  
  203. void event_handler::get_event(event &ev)
  204. {
  205.   event *ep;
  206.   while (!ewaiting)
  207.     event_waiting();
  208.  
  209.   ep=(event *)events.first();
  210.   if (ep)
  211.   { ev=*ep;
  212.     events.unlink((linked_node *)ep);
  213.     delete ep;
  214.     ewaiting=events.first()!=NULL;
  215.   }
  216.   else
  217.   {
  218.  
  219.     if (mhere && (mouse->last_button()!=mouse->button()))
  220.     ev.type=EV_MOUSE_BUTTON;
  221.     else if (mhere && (mouse->lastx()!=mouse->x() ||
  222.                mouse->lasty()!=mouse->y()))
  223.     ev.type=EV_MOUSE_MOVE;
  224.     else ev.type=EV_SPURIOUS;
  225.  
  226.     if (ev.type==EV_MOUSE_MOVE)
  227.     {
  228.       mouse->mouse_sprite()->x=mouse->x();
  229.       mouse->mouse_sprite()->y=mouse->y();
  230.     }
  231.     ewaiting=0;
  232.   }
  233.   // note : that the mouse status
  234.   // should be know even if
  235.   // other event has occured
  236.   ev.mouse_move.x=mouse->x();
  237.   ev.mouse_move.y=mouse->y();
  238.   ev.mouse_button=mouse->button();
  239. }
  240.  
  241.  
  242. void event_handler::add_redraw(int X1, int Y1, int X2, int Y2, void *Start)
  243. {
  244.   event *ev;
  245.   ev=new event;
  246.   ev->type=EV_REDRAW;
  247.   ev->redraw.x1=X1; ev->redraw.x2=X2;
  248.   ev->redraw.y1=Y1; ev->redraw.y2=Y2; ev->redraw.start=Start;
  249.   events.add_end((linked_node *)ev);
  250. }
  251.  
  252. int fd,my_console=-1,child_pid;
  253.  
  254. void die()
  255. {
  256.   close(console_fd);  
  257.   kill(child_pid,SIGUSR1);
  258. }
  259.  
  260.  
  261.  
  262. event_handler::~event_handler()
  263. { 
  264.   die();
  265. }
  266.  
  267. int key_fifo();
  268.  
  269. event_handler::event_handler(image *screen, palette *pal)
  270. {
  271.   CHECK(screen && pal);
  272.   mouse=new JCMouse(screen,pal);
  273.   mhere=mouse->exsist();
  274.   last_keystat=get_key_flags();
  275.   ewaiting=0;
  276.   last_key=-1;
  277.   console_fd=key_fifo();
  278.   atexit(die);  
  279. }
  280.  
  281.  
  282. int key_fifo()  // returns the fd linked to the keydriver
  283. {
  284.   int fd; 
  285.   FILE *fp;
  286.   fp=popen("keydrv","r");
  287.   if (fp)
  288.     fscanf(fp,"%d",&child_pid);   // the keydrv prints out it's fork pid
  289.   if (!fp || !child_pid)
  290.   {
  291.     close_graphics();
  292.     printf("Could not find keydrv, please put it in your path\n");
  293.     exit(1);
  294.   }
  295.   pclose(fp);                   // read it, so we can kill it later
  296.   do
  297.   { usleep(10000);
  298.   } while (access("/tmp/jckey-driver",R_OK)); 
  299.   fd=open("/tmp/jckey-driver",O_RDONLY);
  300.   return fd;
  301. }
  302.