sys/src/cmd/kbmap.c

   1 #include <u.h>
   2 #include <libc.h>
   3 #include <draw.h>
   4 #include <event.h>
   5 #include <keyboard.h>
   6
   7 typedef struct KbMap KbMap;
   8 struct KbMap {
   9         char *name;
  10         char *file;
  11         Rectangle r;
  12         int current;
  13 };
  14
  15 KbMap *map;
  16 int nmap;
  17 Image *lightblue;
  18 Image *justblue;
  19
  20 enum {
  21         PAD = 3,
  22         MARGIN = 5
  23 };
  24
  25 char *dir = "/sys/lib/kbmap";
  26
  27 void*
  28 erealloc(void *v, ulong n)
  29 {
  30         v = realloc(v, n);
  31         if(v == nil)
  32                 sysfatal("out of memory reallocating %lud", n);
  33         return v;
  34 }
  35
  36 void*
  37 emalloc(ulong n)
  38 {
  39         void *v;
  40
  41         v = malloc(n);
  42         if(v == nil)
  43                 sysfatal("out of memory allocating %lud", n);
  44         memset(v, 0, n);
  45         return v;
  46 }
  47
  48 char*
  49 estrdup(char *s)
  50 {
  51         int l;
  52         char *t;
  53
  54         if (s == nil)
  55                 return nil;
  56         l = strlen(s)+1;
  57         t = emalloc(l);
  58         memcpy(t, s, l);
  59
  60         return t;
  61 }
  62
  63 void
  64 init(void)
  65 {
  66         int i, fd, nr;
  67         Dir *pd;
  68
  69         if((fd = open(dir, OREAD)) < 0)
  70                 return;
  71
  72         nmap = nr = dirreadall(fd, &pd);
  73         map = emalloc(nr * sizeof(KbMap));
  74         for(i=0; i<nr; i++){
  75                 map[i].file = emalloc(strlen(dir) + strlen(pd[i].name) + 2);
  76                 sprint(map[i].file, "%s/%s", dir, pd[i].name);
  77                 map[i].name = estrdup(pd[i].name);
  78                 map[i].current = 0;
  79         }
  80         free(pd);
  81
  82         close(fd);
  83 }
  84
  85 void
  86 drawmap(int i)
  87 {
  88         if(map[i].current)
  89                 draw(screen, map[i].r, justblue, nil, ZP);
  90         else
  91                 draw(screen, map[i].r, lightblue, nil, ZP);
  92
  93         _string(screen, addpt(map[i].r.min, Pt(2,0)), display->black, ZP,
  94                 font, map[i].name, nil, strlen(map[i].name),
  95                 map[i].r, nil, ZP, SoverD);
  96         border(screen, map[i].r, 1, display->black, ZP);
  97 }
  98
  99 void
 100 geometry(void)
 101 {
 102         int i, rows;
 103         Rectangle r;
 104
 105         rows = (Dy(screen->r)-2*MARGIN+PAD)/(font->height+PAD);
 106         if(rows < 1)
 107                 rows = 1;
 108
 109         r = Rect(0,0,(Dx(screen->r)-2*MARGIN), font->height);
 110         for(i=0; i<nmap; i++)
 111                 map[i].r = rectaddpt(rectaddpt(r, Pt(MARGIN+(PAD+Dx(r))*(i/rows),
 112                                         MARGIN+(PAD+Dy(r))*(i%rows))), screen->r.min);
 113
 114 }
 115
 116 void
 117 redraw(Image *screen)
 118 {
 119         int i;
 120
 121         draw(screen, screen->r, lightblue, nil, ZP);
 122         for(i=0; i<nmap; i++)
 123                 drawmap(i);
 124         flushimage(display, 1);
 125 }
 126
 127 void
 128 eresized(int new)
 129 {
 130         if(new && getwindow(display, Refmesg) < 0)
 131                 fprint(2,"can't reattach to window");
 132         geometry();
 133         redraw(screen);
 134 }
 135
 136 int
 137 writemap(char *file)
 138 {
 139         int i, fd, ofd;
 140         char buf[8192];
 141
 142         if((fd = open(file, OREAD)) < 0){
 143                 fprint(2, "cannot open %s: %r", file);
 144                 return -1;
 145         }
 146         if((ofd = open("/dev/kbmap", OWRITE)) < 0) {
 147                 fprint(2, "cannot open /dev/kbmap: %r");
 148                 close(fd);
 149                 return -1;
 150         }
 151         while((i = read(fd, buf, sizeof buf)) > 0)
 152                 if(write(ofd, buf, i) != i){
 153                         fprint(2, "writing /dev/kbmap: %r");
 154                         break;
 155                 }
 156
 157         close(fd);
 158         close(ofd);
 159         return 0;
 160 }
 161
 162 void
 163 click(Mouse m)
 164 {
 165         int i, j;
 166         char buf[128];
 167
 168         if(m.buttons == 0 || (m.buttons & ~4))
 169                 return;
 170
 171         for(i=0; i<nmap; i++)
 172                 if(ptinrect(m.xy, map[i].r))
 173                         break;
 174         if(i == nmap)
 175                 return;
 176
 177         do
 178                 m = emouse();
 179         while(m.buttons == 4);
 180
 181         if(m.buttons != 0){
 182                 do
 183                         m = emouse();
 184                 while(m.buttons);
 185                 return;
 186         }
 187
 188         for(j=0; j<nmap; j++)
 189                 if(ptinrect(m.xy, map[j].r))
 190                         break;
 191         if(j != i)
 192                 return;
 193
 194         /* since maps are often just a delta of the distributed map... */
 195         snprint(buf, sizeof buf, "%s/ascii", dir);
 196         writemap(buf);
 197         writemap(map[i].file);
 198
 199         /* clean the previous current map */
 200         for(j=0; j<nmap; j++)
 201                 map[j].current = 0;
 202
 203         map[i].current = 1;
 204
 205         redraw(screen);
 206 }
 207
 208 void
 209 usage(void)
 210 {
 211         fprint(2, "usage: kbmap [file...]\n");
 212         exits("usage");
 213 }
 214
 215 void
 216 main(int argc, char **argv)
 217 {
 218         Event e;
 219         char *c;
 220
 221         if(argc > 1) {
 222                 argv++; argc--;
 223                 map = emalloc((argc)*sizeof(KbMap));
 224                 while(argc--) {
 225                         map[argc].file = estrdup(argv[argc]);
 226                         c = strrchr(map[argc].file, '/');
 227                         map[argc].name = (c == nil ? map[argc].file : c+1);
 228                         map[argc].current = 0;
 229                         nmap++;
 230                 }
 231         } else
 232                 init();
 233
 234         if(initdraw(0, 0, "kbmap") < 0){
 235                 fprint(2, "kbmap: initdraw failed: %r\n");
 236                 exits("initdraw");
 237         }
 238         lightblue = allocimagemix(display, DPalebluegreen, DWhite);
 239         if(lightblue == nil)
 240                 sysfatal("allocimagemix: %r");
 241         justblue = allocimagemix(display, DBlue, DWhite);
 242         if(justblue == nil)
 243                 sysfatal("allocimagemix: %r");
 244
 245         eresized(0);
 246         einit(Emouse|Ekeyboard);
 247
 248         for(;;){
 249                 switch(eread(Emouse|Ekeyboard, &e)){
 250                 case Ekeyboard:
 251                         if(e.kbdc==Kdel || e.kbdc=='q')
 252                                 exits(0);
 253                         break;
 254                 case Emouse:
 255                         if(e.mouse.buttons)
 256                                 click(e.mouse);
 257                         break;
 258                 }
 259         }
 260 }
 261