ref: 5dfb42dcc2a66f99de1f736ec12062417700a9c9
dir: /debug/plmon.c/
#include <u.h>
#include <libc.h>
#include <bio.h>
#include <thread.h>
#include <draw.h>
#include <mouse.h>
#include <keyboard.h>
#include <geometry.h>
enum {
Graphoff = 40,
Slotht = 10,
};
enum {
CMain,
CBack,
CTdelim,
CSelect,
NCOLOR,
};
typedef struct Slot Slot;
typedef struct Task Task;
typedef struct Schedule Schedule;
struct Slot
{
uvlong t0, t1;
};
struct Task
{
char *name;
Slot *times;
ulong ntime;
};
struct Schedule
{
Task *tasks;
ulong ntask;
};
Rectangle UR = {0,0,1,1};
Image *pal[NCOLOR];
RFrame graphrf;
Schedule sched;
int scale;
Slot *curts;
Channel *drawc;
char *units[] = { "ns", "µs", "ms", "s" };
double mag;
int Δx;
void redraw(void);
static Image*
eallocimage(Display *d, Rectangle r, ulong chan, int repl, ulong col)
{
Image *i;
i = allocimage(d, r, chan, repl, col);
if(i == nil)
sysfatal("allocimage: %r");
return i;
}
static void
addt(char *n, Slot s)
{
Task *t;
int i;
t = nil;
for(i = 0; i < sched.ntask; i++)
if(strcmp(n, sched.tasks[i].name) == 0){
t = &sched.tasks[i];
break;
}
if(t == nil){
sched.tasks = realloc(sched.tasks, ++sched.ntask*sizeof(*sched.tasks));
t = &sched.tasks[sched.ntask-1];
memset(t, 0, sizeof *t);
t->name = strdup(n);
}
t->times = realloc(t->times, ++t->ntime*sizeof(*t->times));
t->times[t->ntime-1] = s;
}
static void
printsched(void)
{
Task *t;
Slot *s;
for(t = sched.tasks; t && t < sched.tasks + sched.ntask; t++)
for(s = t->times; s < t->times + t->ntime; s++)
print("%s\t%llud\t%llud\n", t->name, s->t0, s->t1);
}
static void
initcolors(void)
{
pal[CMain] = display->black;
pal[CBack] = display->white;
pal[CTdelim] = eallocimage(display, UR, screen->chan, 1, 0xEEEEEEff);
pal[CSelect] = eallocimage(display, Rect(0,0,2,2), screen->chan, 1, DWhite);
draw(pal[CSelect], UR, display->black, nil, ZP);
draw(pal[CSelect], rectaddpt(UR, Pt(1,1)), display->black, nil, ZP);
}
void
lmb(Mousectl *mc)
{
Mouse m;
for(;;){
m = mc->Mouse;
if(readmouse(mc) < 0)
break;
if((mc->buttons & 7) != 1)
break;
graphrf.p.x += mc->xy.x - m.xy.x;
if(graphrf.p.x > Graphoff)
graphrf.p.x = Graphoff;
redraw();
}
}
void
mmb(Mousectl *mc)
{
enum {
QUIT,
};
static char *items[] = {
[QUIT] "quit",
nil,
};
static Menu menu = { .item = items };
switch(menuhit(2, mc, &menu, _screen)){
case QUIT:
threadexitsall(nil);
}
nbsend(drawc, nil);
}
void
rmb(Mousectl *mc)
{
Task *t;
Slot *s;
Rectangle r;
Point2 p;
int dy;
dy = (Dy(screen->r) - font->height)/sched.ntask;
for(t = sched.tasks; t < sched.tasks+sched.ntask; t++){
graphrf.p.y = (t - sched.tasks)*dy+dy;
for(s = t->times; s < t->times+t->ntime; s++){
p = invrframexform(Pt2(s->t0,0,1), graphrf);
r.min = Pt(p.x,p.y-Slotht);
p = invrframexform(Pt2(s->t1,0,1), graphrf);
r.max = Pt(p.x+1,p.y);
if(r.min.x < Graphoff)
r.min.x = Graphoff;
if(ptinrect(subpt(mc->xy, screen->r.min), r)){
curts = s;
nbsend(drawc, nil);
return;
}
}
}
}
void
zoomin(void)
{
Point2 op;
if(scale == 1)
return;
op = rframexform(Pt2(Graphoff,0,1), graphrf);
graphrf.bx.x = pow10(++scale);
op = invrframexform(op, graphrf);
graphrf.p.x -= op.x-Graphoff;
mag = pow10(abs(scale)%3);
nbsend(drawc, nil);
}
void
zoomout(void)
{
Point2 op;
if(abs(scale) == 3*(nelem(units)-1))
return;
else if(scale == 1)
scale = 0;
op = rframexform(Pt2(Graphoff,0,1), graphrf);
graphrf.bx.x = pow10(--scale);
op = invrframexform(op, graphrf);
graphrf.p.x -= op.x-Graphoff;
mag = pow10(abs(scale)%3);
nbsend(drawc, nil);
}
void
mouse(Mousectl *mc)
{
if(mc->buttons & 1)
lmb(mc);
if(mc->buttons & 2)
mmb(mc);
if(mc->buttons & 4)
rmb(mc);
if(mc->buttons & 8)
zoomin();
if(mc->buttons & 16)
zoomout();
}
void
resized(void)
{
lockdisplay(display);
if(getwindow(display, Refnone) < 0)
sysfatal("resize failed");
unlockdisplay(display);
nbsend(drawc, nil);
}
void
key(Rune r)
{
switch(r){
case Kdel:
case 'q':
threadexitsall(nil);
case Kleft:
graphrf.p.x -= 10;
nbsend(drawc, nil);
break;
case Kright:
graphrf.p.x += 10;
if(graphrf.p.x > Graphoff)
graphrf.p.x = Graphoff;
nbsend(drawc, nil);
break;
}
}
void
redraw(void)
{
Rectangle r;
Slot *s;
Point2 p;
char info[128];
int i, dy, yoff, xoff;
lockdisplay(display);
draw(screen, screen->r, pal[CBack], nil, ZP);
/* time axis (horizontal) */
xoff = fmod(graphrf.p.x, Δx);
for(i = xoff; i < Dx(screen->r); i += Δx){
if(i < Graphoff)
continue;
line(screen, addpt(screen->r.min, Pt(i,Graphoff/2)), addpt(screen->r.min, Pt(i,Graphoff)), 0, 0, 0, pal[CMain], ZP);
line(screen, addpt(screen->r.min, Pt(i,Graphoff)), Pt(screen->r.min.x+i,screen->r.max.y), 0, 0, 0, pal[CTdelim], ZP);
p = rframexform(Pt2(i,0,1), graphrf);
snprint(info, sizeof info, "%.0f", p.x*mag*pow10(scale));
string(screen, addpt(screen->r.min, Pt(i+2,Graphoff/2-2)), pal[CMain], ZP, font, info);
}
// snprint(info, sizeof info, "t(%s) %.0f/px", units[abs(scale)/3], mag);
snprint(info, sizeof info, "t(%s)", units[abs(scale)/3]);
if(curts != nil)
snprint(info+strlen(info), sizeof(info)-strlen(info), " t0 %.2f t1 %.2f Δt %.2f", curts->t0*pow10(scale-(scale%3)), curts->t1*pow10(scale-(scale%3)), (curts->t1 - curts->t0)*pow10(scale-(scale%3)));
string(screen, addpt(screen->r.min, Pt(Graphoff+2,0)), pal[CMain], ZP, font, info);
line(screen, addpt(screen->r.min, Pt(0, Graphoff)), addpt(screen->r.min, Pt(Dx(screen->r), Graphoff)), 0, 0, 0, pal[CMain], ZP);
/* tasks axis (vertical) */
dy = (Dy(screen->r) - font->height)/sched.ntask;
for(i = 0; i < sched.ntask; i++){
yoff = i*dy+dy;
string(screen, addpt(screen->r.min, Pt(0,yoff)), pal[CMain], ZP, font, sched.tasks[i].name);
line(screen, addpt(screen->r.min, Pt(Graphoff/2,yoff+font->height)), addpt(screen->r.min, Pt(Graphoff,yoff+font->height)), 0, 0, 0, pal[CMain], ZP);
graphrf.p.y = yoff;
for(s = sched.tasks[i].times; s < sched.tasks[i].times + sched.tasks[i].ntime; s++){
p = invrframexform(Pt2(s->t0,0,1), graphrf);
if(p.x > Dx(screen->r))
break;
r.min = Pt(p.x,p.y-Slotht);
p = invrframexform(Pt2(s->t1,0,1), graphrf);
if(p.x < Graphoff)
continue;
r.max = Pt(p.x+1,p.y);
if(r.min.x < Graphoff)
r.min.x = Graphoff;
draw(screen, rectaddpt(r, screen->r.min), s == curts? pal[CSelect]: pal[CMain], nil, ZP);
}
}
line(screen, addpt(screen->r.min, Pt(Graphoff, 0)), addpt(screen->r.min, Pt(Graphoff, Dy(screen->r))), 0, 0, 0, pal[CMain], ZP);
flushimage(display, 1);
unlockdisplay(display);
}
void
usage(void)
{
fprint(2, "usage: %s\n", argv0);
exits("usage");
}
void
threadmain(int argc, char *argv[])
{
Mousectl *mc;
Keyboardctl *kc;
Biobuf *bin;
Slot s;
Rune r;
char *line, *f[3];
ulong nf;
ARGBEGIN{
default: usage();
}ARGEND
if(argc != 0)
usage();
bin = Bfdopen(0, OREAD);
if(bin == nil)
sysfatal("Bfdopen: %r");
while((line = Brdline(bin, '\n')) != nil){
line[Blinelen(bin)-1] = 0;
nf = tokenize(line, f, 3);
if(nf != 3)
continue;
s.t0 = strtoul(f[1], nil, 10);
s.t1 = strtoul(f[2], nil, 10);
if(s.t0 >= s.t1)
continue;
addt(f[0], s);
}
Bterm(bin);
if(initdraw(nil, nil, "plmon") < 0)
sysfatal("initdraw: %r");
if((kc = initkeyboard(nil)) == nil)
sysfatal("initkeyboard: %r");
if((mc = initmouse(nil, screen)) == nil)
sysfatal("initmouse: %r");
initcolors();
scale = -3; /* µs */
graphrf.p = Pt2(Graphoff,Graphoff,1);
graphrf.bx = Vec2(pow10(scale),0);
graphrf.by = Vec2(0,1);
Δx = 100;
mag = pow10(abs(scale)%3);
drawc = chancreate(sizeof(void*), 1);
display->locking = 1;
unlockdisplay(display);
nbsend(drawc, nil);
enum { MOUSE, RESIZE, KEY, DRAW };
Alt a[] = {
{mc->c, &mc->Mouse, CHANRCV},
{mc->resizec, nil, CHANRCV},
{kc->c, &r, CHANRCV},
{drawc, nil, CHANRCV},
{nil, nil, CHANEND},
};
for(;;)
switch(alt(a)){
case MOUSE: mouse(mc); break;
case RESIZE: resized(); break;
case KEY: key(r); break;
case DRAW: redraw(); break;
}
}