#include <u.h>
#include <libc.h>
#include <bio.h>
#include <thread.h>
#include <plumb.h>
#include "dat.h"

Window*
newwindow(void)
{
       char buf[12];
       Window *w;

       w = emalloc(sizeof(Window));
       w->ctl = open("/mnt/wsys/new/ctl", ORDWR|OCEXEC);
       if(w->ctl<0 || read(w->ctl, buf, 12)!=12)
               error("can't open window ctl file: %r");
       ctlprint(w->ctl, "noscroll\n");
       w->id = atoi(buf);
       w->event = winopenfile(w, "event");
       w->addr = -1;   /* will be opened when needed */
       w->body = nil;
       w->data = -1;
       w->cevent = chancreate(sizeof(Event*), 0);
       return w;
}

void
winsetdump(Window *w, char *dir, char *cmd)
{
       if(dir != nil)
               ctlprint(w->ctl, "dumpdir %s\n", dir);
       if(cmd != nil)
               ctlprint(w->ctl, "dump %s\n", cmd);
}

void
wineventproc(void *v)
{
       Window *w;
       int i;

       w = v;
       for(i=0; ; i++){
               if(i >= NEVENT)
                       i = 0;
               wingetevent(w, &w->e[i]);
               sendp(w->cevent, &w->e[i]);
       }
}

static int
winopenfile1(Window *w, char *f, int m)
{
       char buf[64];
       int fd;

       sprint(buf, "/mnt/wsys/%d/%s", w->id, f);
       fd = open(buf, m|OCEXEC);
       if(fd < 0)
               error("can't open window file %s: %r", f);
       return fd;
}

int
winopenfile(Window *w, char *f)
{
       return winopenfile1(w, f, ORDWR);
}

void
wintagwrite(Window *w, char *s, int n)
{
       int fd;

       fd = winopenfile(w, "tag");
       if(write(fd, s, n) != n)
               error("tag write: %r");
       close(fd);
}

void
winname(Window *w, char *s)
{
       ctlprint(w->ctl, "name %s\n", s);
}

void
winopenbody(Window *w, int mode)
{
       char buf[256];

       sprint(buf, "/mnt/wsys/%d/body", w->id);
       w->body = Bopen(buf, mode|OCEXEC);
       if(w->body == nil)
               error("can't open window body file: %r");
}

void
winclosebody(Window *w)
{
       if(w->body != nil){
               Bterm(w->body);
               w->body = nil;
       }
}

void
winwritebody(Window *w, char *s, int n)
{
       if(w->body == nil)
               winopenbody(w, OWRITE);
       if(Bwrite(w->body, s, n) != n)
               error("write error to window: %r");
}

int
wingetec(Window *w)
{
       if(w->nbuf == 0){
               w->nbuf = read(w->event, w->buf, sizeof w->buf);
               if(w->nbuf <= 0){
                       /* probably because window has exited, and only called by wineventproc, so just shut down */
                       threadexits(nil);
               }
               w->bufp = w->buf;
       }
       w->nbuf--;
       return *w->bufp++;
}

int
wingeten(Window *w)
{
       int n, c;

       n = 0;
       while('0'<=(c=wingetec(w)) && c<='9')
               n = n*10+(c-'0');
       if(c != ' ')
               error("event number syntax");
       return n;
}

int
wingeter(Window *w, char *buf, int *nb)
{
       Rune r;
       int n;

       r = wingetec(w);
       buf[0] = r;
       n = 1;
       if(r >= Runeself) {
               while(!fullrune(buf, n))
                       buf[n++] = wingetec(w);
               chartorune(&r, buf);
       }
       *nb = n;
       return r;
}

void
wingetevent(Window *w, Event *e)
{
       int i, nb;

       e->c1 = wingetec(w);
       e->c2 = wingetec(w);
       e->q0 = wingeten(w);
       e->q1 = wingeten(w);
       e->flag = wingeten(w);
       e->nr = wingeten(w);
       if(e->nr > EVENTSIZE)
               error("event string too long");
       e->nb = 0;
       for(i=0; i<e->nr; i++){
               e->r[i] = wingeter(w, e->b+e->nb, &nb);
               e->nb += nb;
       }
       e->r[e->nr] = 0;
       e->b[e->nb] = 0;
       if(wingetec(w) != '\n')
               error("event syntax error");
}

void
winwriteevent(Window *w, Event *e)
{
       fprint(w->event, "%c%c%d %d\n", e->c1, e->c2, e->q0, e->q1);
}

void
winread(Window *w, uint q0, uint q1, char *data)
{
       int m, n, nr;
       char buf[256];

       if(w->addr < 0)
               w->addr = winopenfile(w, "addr");
       if(w->data < 0)
               w->data = winopenfile(w, "data");
       m = q0;
       while(m < q1){
               n = sprint(buf, "#%d", m);
               if(write(w->addr, buf, n) != n)
                       error("error writing addr: %r");
               n = read(w->data, buf, sizeof buf);
               if(n <= 0)
                       error("reading data: %r");
               nr = utfnlen(buf, n);
               while(m+nr >q1){
                       do; while(n>0 && (buf[--n]&0xC0)==0x80);
                       --nr;
               }
               if(n == 0)
                       break;
               memmove(data, buf, n);
               data += n;
               *data = 0;
               m += nr;
       }
}

void
windormant(Window *w)
{
       if(w->addr >= 0){
               close(w->addr);
               w->addr = -1;
       }
       if(w->body != nil){
               Bterm(w->body);
               w->body = nil;
       }
       if(w->data >= 0){
               close(w->data);
               w->data = -1;
       }
}


int
windel(Window *w, int sure)
{
       if(sure)
               write(w->ctl, "delete\n", 7);
       else if(write(w->ctl, "del\n", 4) != 4)
               return 0;
       /* event proc will die due to read error from event file */
       windormant(w);
       close(w->ctl);
       w->ctl = -1;
       close(w->event);
       w->event = -1;
       return 1;
}

void
winclean(Window *w)
{
       if(w->body)
               Bflush(w->body);
       ctlprint(w->ctl, "clean\n");
}

int
winsetaddr(Window *w, char *addr, int errok)
{
       if(w->addr < 0)
               w->addr = winopenfile(w, "addr");
       if(write(w->addr, addr, strlen(addr)) < 0){
               if(!errok)
                       error("error writing addr(%s): %r", addr);
               return 0;
       }
       return 1;
}

int
winselect(Window *w, char *addr, int errok)
{
       if(winsetaddr(w, addr, errok)){
               ctlprint(w->ctl, "dot=addr\n");
               return 1;
       }
       return 0;
}

char*
winreadbody(Window *w, int *np) /* can't use readfile because acme doesn't report the length */
{
       char *s;
       int m, na, n;

       if(w->body != nil)
               winclosebody(w);
       winopenbody(w, OREAD);
       s = nil;
       na = 0;
       n = 0;
       for(;;){
               if(na < n+512){
                       na += 1024;
                       s = realloc(s, na+1);
               }
               m = Bread(w->body, s+n, na-n);
               if(m <= 0)
                       break;
               n += m;
       }
       s[n] = 0;
       winclosebody(w);
       *np = n;
       return s;
}

char*
winselection(Window *w)
{
       int fd, m, n;
       char *buf;
       char tmp[256];

       fd = winopenfile1(w, "rdsel", OREAD);
       if(fd < 0)
               error("can't open rdsel: %r");
       n = 0;
       buf = nil;
       for(;;){
               m = read(fd, tmp, sizeof tmp);
               if(m <= 0)
                       break;
               buf = erealloc(buf, n+m+1);
               memmove(buf+n, tmp, m);
               n += m;
               buf[n] = '\0';
       }
       close(fd);
       return buf;
}

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.