#include <u.h>
#include <libc.h>
#include <draw.h>
#include <event.h>
#include <keyboard.h>

typedef struct KbMap KbMap;
struct KbMap {
       char *name;
       char *file;
       Rectangle r;
       int current;
};

KbMap *map;
int nmap;
Image *lightblue;
Image *justblue;

enum {
       PAD = 3,
       MARGIN = 5
};

char *dir = "/sys/lib/kbmap";

void*
erealloc(void *v, ulong n)
{
       v = realloc(v, n);
       if(v == nil)
               sysfatal("out of memory reallocating %lud", n);
       return v;
}

void*
emalloc(ulong n)
{
       void *v;

       v = malloc(n);
       if(v == nil)
               sysfatal("out of memory allocating %lud", n);
       memset(v, 0, n);
       return v;
}

char*
estrdup(char *s)
{
       int l;
       char *t;

       if (s == nil)
               return nil;
       l = strlen(s)+1;
       t = emalloc(l);
       memcpy(t, s, l);

       return t;
}

void
init(void)
{
       int i, fd, nr;
       Dir *pd;

       if((fd = open(dir, OREAD)) < 0)
               return;

       nmap = nr = dirreadall(fd, &pd);
       map = emalloc(nr * sizeof(KbMap));
       for(i=0; i<nr; i++){
               map[i].file = emalloc(strlen(dir) + strlen(pd[i].name) + 2);
               sprint(map[i].file, "%s/%s", dir, pd[i].name);
               map[i].name = estrdup(pd[i].name);
               map[i].current = 0;
       }
       free(pd);

       close(fd);
}

void
drawmap(int i)
{
       if(map[i].current)
               draw(screen, map[i].r, justblue, nil, ZP);
       else
               draw(screen, map[i].r, lightblue, nil, ZP);

       _string(screen, addpt(map[i].r.min, Pt(2,0)), display->black, ZP,
               font, map[i].name, nil, strlen(map[i].name),
               map[i].r, nil, ZP, SoverD);
       border(screen, map[i].r, 1, display->black, ZP);
}

void
geometry(void)
{
       int i, rows;
       Rectangle r;

       rows = (Dy(screen->r)-2*MARGIN+PAD)/(font->height+PAD);

       r = Rect(0,0,(Dx(screen->r)-2*MARGIN), font->height);
       for(i=0; i<nmap; i++)
               map[i].r = rectaddpt(rectaddpt(r, Pt(MARGIN+(PAD+Dx(r))*(i/rows),
                                       MARGIN+(PAD+Dy(r))*(i%rows))), screen->r.min);

}

void
redraw(Image *screen)
{
       int i;

       draw(screen, screen->r, lightblue, nil, ZP);
       for(i=0; i<nmap; i++)
               drawmap(i);
       flushimage(display, 1);
}

void
eresized(int new)
{
       if(new && getwindow(display, Refmesg) < 0)
               fprint(2,"can't reattach to window");
       geometry();
       redraw(screen);
}

int
writemap(char *file)
{
       int i, fd, ofd;
       char buf[8192];

       if((fd = open(file, OREAD)) < 0){
               fprint(2, "cannot open %s: %r", file);
               return -1;
       }
       if((ofd = open("/dev/kbmap", OWRITE)) < 0) {
               fprint(2, "cannot open /dev/kbmap: %r");
               close(fd);
               return -1;
       }
       while((i = read(fd, buf, sizeof buf)) > 0)
               if(write(ofd, buf, i) != i){
                       fprint(2, "writing /dev/kbmap: %r");
                       break;
               }

       close(fd);
       close(ofd);
       return 0;
}

void
click(Mouse m)
{
       int i, j;
       char buf[128];

       if(m.buttons == 0 || (m.buttons & ~4))
               return;

       for(i=0; i<nmap; i++)
               if(ptinrect(m.xy, map[i].r))
                       break;
       if(i == nmap)
               return;

       do
               m = emouse();
       while(m.buttons == 4);

       if(m.buttons != 0){
               do
                       m = emouse();
               while(m.buttons);
               return;
       }

       for(j=0; j<nmap; j++)
               if(ptinrect(m.xy, map[j].r))
                       break;
       if(j != i)
               return;

       /* since maps are often just a delta of the distributed map... */
       snprint(buf, sizeof buf, "%s/ascii", dir);
       writemap(buf);
       writemap(map[i].file);

       /* clean the previous current map */
       for(j=0; j<nmap; j++)
               map[j].current = 0;

       map[i].current = 1;

       redraw(screen);
}

void
usage(void)
{
       fprint(2, "usage: kbmap [file...]\n");
       exits("usage");
}

void
main(int argc, char **argv)
{
       Event e;
       char *c;

       if(argc > 1) {
               argv++; argc--;
               map = emalloc((argc)*sizeof(KbMap));
               while(argc--) {
                       map[argc].file = estrdup(argv[argc]);
                       c = strrchr(map[argc].file, '/');
                       map[argc].name = (c == nil ? map[argc].file : c+1);
                       map[argc].current = 0;
                       nmap++;
               }
       } else
               init();

       if(initdraw(0, 0, "kbmap") < 0){
               fprint(2, "kbmap: initdraw failed: %r\n");
               exits("initdraw");
       }
       lightblue = allocimagemix(display, DPalebluegreen, DWhite);
       if(lightblue == nil)
               sysfatal("allocimagemix: %r");
       justblue = allocimagemix(display, DBlue, DWhite);
       if(justblue == nil)
               sysfatal("allocimagemix: %r");

       eresized(0);
       einit(Emouse|Ekeyboard);

       for(;;){
               switch(eread(Emouse|Ekeyboard, &e)){
               case Ekeyboard:
                       if(e.kbdc==Kdel || e.kbdc=='q')
                               exits(0);
                       break;
               case Emouse:
                       if(e.mouse.buttons)
                               click(e.mouse);
                       break;
               }
       }
}

You are viewing proxied material from sdf.org. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.