static int WndProcST(t_x11 *x11, t_dlgitem *dlgitem, XEvent *event)
{
t_statictext *st;
t_windata *win;
int i, dy;
if (dlgitem->type != edlgST)
{
gmx_incons("st processing");
}
st = &(dlgitem->u.statictext);
win = &(dlgitem->win);
switch (event->type)
{
case Expose:
dy = XTextHeight(x11->font)+OFFS_Y;
for (i = 0; (i < st->nlines); i++)
{
TextInRect(x11, win->self, st->lines[i],
0, OFFS_Y+i*dy, win->width, dy, eXLeft, eYCenter);
}
break;
default:
return DefWndProc(x11, dlgitem, event);
}
return ITEMOK;
}
static int WndProcBN(t_x11 *x11, t_dlgitem *dlgitem, XEvent *event)
{
t_windata *win;
int x, w, th;
if (dlgitem->type != edlgBN)
{
gmx_incons("button processing");
}
win = &(dlgitem->win);
w = XTextWidth(x11->font, win->text, strlen(win->text));
x = (win->width-w)/2;
th = XTextHeight(x11->font)+OFFS_Y;
switch (event->type)
{
case Expose:
RectWin(x11->disp, x11->gc, win, x11->fg);
TextInRect(x11, win->self, win->text, 0, 0, win->width, th, eXCenter, eYCenter);
break;
case ButtonPress:
return BNPRESSED;
case EnterNotify:
XDrawLine(x11->disp, win->self, x11->gc, x-1, th, x+w, th);
break;
case LeaveNotify:
XSetForeground(x11->disp, x11->gc, x11->bg);
XDrawLine(x11->disp, win->self, x11->gc, x-1, th, x+w, th);
XSetForeground(x11->disp, x11->gc, x11->fg);
break;
default:
return DefWndProc(x11, dlgitem, event);
}
return ITEMOK;
}
static int WndProcGB(t_x11 *x11, t_dlgitem *dlgitem, XEvent *event)
{
t_windata *win;
int x, y;
if (dlgitem->type != edlgGB)
{
gmx_incons("gb processing");
}
win = &(dlgitem->win);
x = XTextWidth(x11->font, win->text, strlen(win->text));
y = XTextHeight(x11->font);
switch (event->type)
{
case Expose:
XSetForeground(x11->disp, x11->gc, x11->fg);
XDrawRoundRect(x11->disp, win->self, x11->gc, 0, y/2,
win->width-1, win->height-y/2-1);
XClearArea(x11->disp, win->self, OFFS_X, 0, x+OFFS_X, y, False);
TextInRect(x11, win->self, win->text, 2*OFFS_X, 0, x, y, eXCenter, eYCenter);
break;
case EnterNotify:
case LeaveNotify:
break;
default:
return DefWndProc(x11, dlgitem, event);
}
return ITEMOK;
}
t_dlgitem *CreateGroupBox(t_x11 *x11,
const char *szLab, t_id id,
int nitems, t_id items[],
int x0, int y0, int w, int h, int bw)
{
t_dlgitem *dlgitem;
dlgitem = newitem(x11);
if (h == 0)
{
h = XTextHeight(x11->font)+OFFS_Y;
}
if (w == 0)
{
w = XTextWidth(x11->font, szLab, strlen(szLab))+2*OFFS_X;
}
InitWin(&(dlgitem->win), x0, y0, w, h, bw, szLab);
dlgitem->GroupID = id;
dlgitem->ID = id;
dlgitem->type = edlgGB;
dlgitem->u.groupbox.nitems = nitems;
snew(dlgitem->u.groupbox.item, nitems);
memcpy((char *)dlgitem->u.groupbox.item, (char *)items,
nitems*sizeof(items[0]));
dlgitem->WndProc = WndProcGB;
return dlgitem;
}
t_dlgitem *CreateEditText(t_x11 *x11,
const char *title,
int screenbuf,char *buf, t_id id,t_id groupid,
int x0,int y0,int w,int h,int bw)
{
t_dlgitem *dlgitem;
t_edittext *et;
dlgitem=newitem(x11);
if (h==0) h=XTextHeight(x11->font)+OFFS_Y;
if (w==0) {
char *test;
snew(test,screenbuf);
memset(test,'w',screenbuf);
w=XTextWidth(x11->font,test,screenbuf)+
XTextWidth(x11->font,title,strlen(title))+
2*XCARET+2*OFFS_X;
sfree(test);
}
InitWin(&(dlgitem->win),x0,y0,w,h,bw,title);
dlgitem->ID=id;
dlgitem->GroupID=groupid;
dlgitem->type=edlgET;
et=&(dlgitem->u.edittext);
snew(et->buf,STRLEN);
strcpy(et->buf,buf);
et->buflen=screenbuf;
et->strbegin=0;
et->bChanged=FALSE;
dlgitem->WndProc=WndProcET;
return dlgitem;
}
t_dlgitem *CreateCheckBox(t_x11 *x11,
const char *szLab, gmx_bool bCheckedInitial, t_id id,
t_id groupid,
int x0, int y0, int w, int h, int bw)
{
t_dlgitem *dlgitem;
dlgitem = newitem(x11);
if (h == 0)
{
h = XTextHeight(x11->font)+OFFS_Y;
}
if (w == 0)
{
w = XTextWidth(x11->font, szLab, strlen(szLab))+OFFS_X+h;
}
InitWin(&(dlgitem->win), x0, y0, w, h, bw, szLab);
dlgitem->ID = id;
dlgitem->GroupID = groupid;
dlgitem->type = edlgCB;
dlgitem->u.checkbox.bChecked = bCheckedInitial;
dlgitem->WndProc = WndProcCB;
return dlgitem;
}
t_dlgitem *CreateStaticText(t_x11 *x11,
int nlines, char * const * lines, t_id id,
t_id groupid,
int x0, int y0, int w, int h, int bw)
{
t_dlgitem *dlgitem;
int i;
dlgitem = newitem(x11);
if (h == 0)
{
h = (XTextHeight(x11->font)+OFFS_Y)*nlines+OFFS_Y;
}
if (w == 0)
{
for (i = 0; (i < nlines); i++)
{
w = max(w, XTextWidth(x11->font, lines[i], strlen(lines[i])));
}
w += 2*OFFS_X;
}
InitWin(&(dlgitem->win), x0, y0, w, h, bw, NULL);
dlgitem->ID = id;
dlgitem->GroupID = groupid;
dlgitem->type = edlgST;
dlgitem->u.statictext.nlines = nlines;
snew(dlgitem->u.statictext.lines, nlines);
for (i = 0; (i < nlines); i++)
{
dlgitem->u.statictext.lines[i] = strdup(lines[i]);
}
dlgitem->WndProc = WndProcST;
return dlgitem;
}
static t_sc *init_sc(t_x11 *x11,Window Parent,char *rgb)
{
t_sc *sc;
Window w;
int i;
snew(sc,1);
InitWin(&sc->wd,0,0,400,300,1,"Show Colours");
sc->wd.self=XCreateSimpleWindow(x11->disp,Parent,sc->wd.x,sc->wd.y,
sc->wd.width,sc->wd.height,
sc->wd.bwidth,WHITE,BLACK);
x11->RegisterCallback(x11,sc->wd.self,Parent,scCallBack,sc);
x11->SetInputMask(x11,sc->wd.self,ButtonPressMask | ExposureMask |
StructureNotifyMask);
InitWin(&sc->but,0,0,sc->wd.width-2,XTextHeight(x11->font)+2,1,"Quit");
sc->but.self=XCreateSimpleWindow(x11->disp,sc->wd.self,sc->but.x,sc->but.y,
sc->but.width,sc->but.height,
sc->but.bwidth,BLACK,BLACK);
x11->RegisterCallback(x11,sc->but.self,sc->but.self,BCallBack,sc);
x11->SetInputMask(x11,sc->but.self,ButtonPressMask | ExposureMask |
StructureNotifyMask | EnterWindowMask |
LeaveWindowMask);
read_col(x11,sc,rgb);
fprintf(stderr,"%d colors found\n",sc->ncol);
fprintf(stderr,"%6s%6s%6s\t\t%-20s\n","Red","Green","Blue","name");
for(i=0; (i<sc->ncol); i++) {
sc->col[i].wd.self=w=XCreateSimpleWindow(x11->disp,sc->wd.self,0,0,1,1,0,
BLACK,sc->col[i].xc.pixel);
x11->RegisterCallback(x11,w,sc->wd.self,ColCallBack,&(sc->col[i]));
x11->SetInputMask(x11,w,ButtonPressMask);
}
return sc;
}
t_dlgitem *CreateRadioButton(t_x11 *x11,
const char *szLab, gmx_bool bSet, t_id id,
t_id groupid,
int x0, int y0, int w, int h, int bw)
{
t_dlgitem *dlgitem;
dlgitem = newitem(x11);
if (h == 0)
{
h = XTextHeight(x11->font)+OFFS_Y;
}
if (w == 0)
{
w = XTextWidth(x11->font, szLab, strlen(szLab))+OFFS_X+h;
}
InitWin(&(dlgitem->win), x0, y0, w, h, bw, szLab);
dlgitem->ID = id;
dlgitem->GroupID = groupid;
dlgitem->type = edlgRB;
dlgitem->u.radiobutton.bSelect = bSet;
dlgitem->WndProc = WndProcRB;
return dlgitem;
}
/*****************************
*
* Routines to create dialog items, all items have an id
* which you can use to extract info. It is possible to have
* multiple items with the same id but it may then not be possible
* to extract information.
* All routines take the position relative to the parent dlg
* and the size and border width.
* If the width and height are set to zero initially, they will
* be calculated and set by the routine. With the dlgitem manipulation
* routines listed below, the application can then move the items around
* on the dlg box, and if wished resize them.
*
****************************/
t_dlgitem *CreateButton(t_x11 *x11,
const char *szLab, gmx_bool bDef, t_id id, t_id groupid,
int x0, int y0, int w, int h, int bw)
{
t_dlgitem *dlgitem;
char *lab;
dlgitem = newitem(x11);
if (h == 0)
{
h = XTextHeight(x11->font)+2*OFFS_Y;
}
if (w == 0)
{
w = XTextWidth(x11->font, szLab, strlen(szLab))+2*OFFS_X;
}
if (bDef)
{
snew(lab, strlen(szLab)+7); /* 6 for >> << and 1 for \0 */
sprintf(lab, ">> %s <<", szLab);
}
else
{
lab = strdup(szLab);
}
InitWin(&(dlgitem->win), x0, y0, w, h, bw, szLab);
sfree(lab);
dlgitem->ID = id;
dlgitem->GroupID = groupid;
dlgitem->type = edlgBN;
dlgitem->u.button.bDefault = bDef;
dlgitem->WndProc = WndProcBN;
return dlgitem;
}
static gmx_bool xrCallBack(struct t_x11 *x11, XEvent *event, Window w, void *data)
{
t_app *app;
t_xrama *xr;
char buf[256];
int i;
(void)XTextHeight(x11->font);
app = (t_app *)data;
xr = app->xr;
scx = app->xrwd.width/(2.0*M_PI);
scy = app->xrwd.height/(2.0*M_PI);
switch (event->type)
{
case Expose:
XClearWindow(x11->disp, app->xrwd.self);
XDrawLine(x11->disp, app->xrwd.self, x11->gc,
SX(0), SY(-M_PI)+1, SX(0), SY(M_PI)-1);
XDrawLine(x11->disp, app->xrwd.self, x11->gc,
SX(-M_PI)+1, SY(0), SX(M_PI)-1, SY(0));
TextInRect(x11, app->xrwd.self, "Phi", SX(M_PI)-50, SY(0)+4, 46, 20, eXRight, eYTop);
TextInRect(x11, app->xrwd.self, "Psi", SX(0)+4, 4, 46, 20, eXLeft, eYTop);
for (i = 0; (i < xr->npp); i++)
{
if (app->bShowGly || !app->bIsGly[i])
{
plot_pp(x11, app->xrwd.self, &(xr->pp[i]), xr->dih);
}
}
break;
case ButtonPress:
if (label_pp(x11, app->xrwd.self, xr->npp, xr->pp, xr->dih,
event->xbutton.x, event->xbutton.y))
{
ExposeWin(x11->disp, app->xrwd.self);
}
break;
case ConfigureNotify:
app->xrwd.width = event->xconfigure.width;
app->xrwd.height = event->xconfigure.height;
break;
}
if (app->status == esGo)
{
if (!new_data(app->xr))
{
app->status = ebStop;
}
else
{
ExposeWin(x11->disp, app->xrwd.self);
sprintf(buf, "Rama: t=%.2f", app->xr->t);
XSetStandardProperties(x11->disp, app->wd.self, buf,
"Rama", 0, NULL, 0, NULL);
}
}
return FALSE;
}
static void plot_pp(t_x11 *x11,Window w,t_phipsi *pp,t_dih dih[])
{
int x0,y0;
int th=(XTextHeight(x11->font)+6)/2;
x0=SX(dih[pp->iphi].ang);
y0=SY(dih[pp->ipsi].ang);
XFillRectangle(x11->disp,w,x11->gc,x0-1,y0-1,4,4);
/* Draw Label ? */
if (pp->bShow)
TextInRect(x11,w,pp->label,x0+6,y0-th,30,2*th,eXLeft,eYCenter);
}
void SpecialTextInRect(t_x11 *x11, XFontStruct *font, Drawable win,
const char *s, int x, int y, int width, int height,
eXPos eX, eYPos eY)
{
int fw, fh, x0, y0;
XFontStruct *f;
if (font)
{
XSetFont(x11->disp, x11->gc, font->fid);
f = font;
}
else
{
f = x11->font;
}
fw = XTextWidth(f, s, strlen(s));
fh = XTextHeight(f);
switch (eX)
{
case eXLeft:
x0 = x;
break;
case eXRight:
x0 = x+width-fw;
break;
case eXCenter:
default:
x0 = x+(width-fw)/2;
break;
}
switch (eY)
{
case eYTop:
y0 = y+f->ascent;
break;
case eYBottom:
y0 = y+height-f->descent;
break;
case eYCenter:
default:
y0 = y+(height-fh)/2+f->ascent;
break;
}
XDrawString(x11->disp, win, x11->gc, x0, y0, s, strlen(s));
if (font)
{
XSetFont(x11->disp, x11->gc, x11->font->fid);
}
}
static void size_app(t_x11 *x11,t_app *app)
{
int i,dx,th;
th=XTextHeight(x11->font)+4;
dx=app->wd.width/ebutNR;
for(i=0; (i<ebutNR); i++) {
app->but[i].width=dx-4;
app->but[i].height=th+4;
XMoveResizeWindow(x11->disp,app->but[i].self,i*dx+2,2,dx-4,th+4);
}
XMoveResizeWindow(x11->disp,app->xrwd.self,2,th+10,
app->wd.width-6,app->wd.height-th-10-4);
}
t_butbox *init_bbox(t_x11 *x11, Window Parent, Window SendTo,
int width, unsigned long fg, unsigned long bg)
{
t_butbox *bbox;
static const char *lbut[IDBUTNR] = {
"< X-Rotate >", "< Y-Rotate >", "< Z-Rotate >",
"< X-Move >", "< Y-Move >", "< Z-Move >", "< Scale >",
};
int i, y0, h0;
t_mwbut *but;
Window DrawOn;
snew(bbox, 1);
bbox->nbut = IDBUTNR;
snew(bbox->b, bbox->nbut);
y0 = XTextHeight(x11->font)+2*(AIR+BORDER);
InitWin(&(bbox->wd), 0, 0, /*width,(y0+AIR)*IDBUTNR+AIR+2*BORDER,*/ 1, 1,
1, "Button Box");
width -= 2*AIR+2*BORDER;
bbox->wd.self = XCreateSimpleWindow(x11->disp, Parent,
bbox->wd.x, bbox->wd.y, bbox->wd.width,
bbox->wd.height, bbox->wd.bwidth,
fg, bg);
x11->RegisterCallback(x11, bbox->wd.self, Parent, BBCallBack, bbox);
x11->SetInputMask(x11, bbox->wd.self, StructureNotifyMask);
DrawOn = bbox->wd.self;
h0 = AIR;
for (i = 0; (i < bbox->nbut); i++)
{
but = &(bbox->b[i]);
InitWin(&but->wd, AIR, h0, width, y0, 1, lbut[i]);
h0 += y0+AIR;
but->wd.Parent = SendTo;
but->ID = i;
but->wd.self = XCreateSimpleWindow(x11->disp, DrawOn,
but->wd.x, but->wd.y,
but->wd.width, but->wd.height,
but->wd.bwidth, bg, bg);
x11->RegisterCallback(x11, but->wd.self, DrawOn, ButtonCallBack, but);
x11->SetInputMask(x11, but->wd.self, ExposureMask | ButtonPressMask |
EnterLeave);
}
return bbox;
}
static gmx_bool VBCallBack(t_x11 *x11, XEvent *event, Window w, void *data)
{
t_butbox *vbox;
int y0;
if (event->type == Expose)
{
vbox = (t_butbox *)data;
y0 = XTextHeight(x11->font)+2*AIR+1;
XSetForeground(x11->disp, x11->gc, WHITE);
XClearArea(x11->disp, vbox->wd.self, 1, 1, vbox->wd.width-2, y0-1, False);
TextInRect(x11, vbox->wd.self, vbox->wd.text,
1, 1, vbox->wd.width-2, y0-1, eXLeft, eYCenter);
XDrawLine(x11->disp, vbox->wd.self, x11->gc, 0, y0, vbox->wd.width, y0);
XSetForeground(x11->disp, x11->gc, x11->fg);
}
return FALSE;
}
/*****************************
*
* Window Procedures and helpful functions
*
****************************/
static void ShowCaret(t_x11 *x11, t_dlgitem *dlgitem)
{
t_edittext *et;
if (dlgitem->type == edlgET) {
int x,y1,y2;
et=&(dlgitem->u.edittext);
x=XTextWidth(x11->font,dlgitem->win.text,strlen(dlgitem->win.text))+XCARET+
XTextWidth(x11->font,(char*) &(et->buf[et->strbegin]),et->pos);
y1=(dlgitem->win.height-XTextHeight(x11->font))/2;
y2=(dlgitem->win.height-y1);
y1--, y2++;
XDrawLine(x11->disp,dlgitem->win.self,x11->gc,x-XCARET,y1,x+XCARET,y1);
XDrawLine(x11->disp,dlgitem->win.self,x11->gc,x,y1,x,y2);
XDrawLine(x11->disp,dlgitem->win.self,x11->gc,x-XCARET,y2,x+XCARET,y2);
}
}
static gmx_bool scCallBack(struct t_x11 *x11, XEvent *event, Window w, void *data)
{
t_sc *sc;
int i;
int nx, ny, X, Y, Dx, Dy, th;
float x, y, dx, dy;
th = XTextHeight(x11->font)+6;
sc = (t_sc *)data;
switch (event->type)
{
case ConfigureNotify:
x = sc->wd.width = event->xconfigure.width;
y = sc->wd.height = event->xconfigure.height-th;
if ((x >= 100) && (y >= 100))
{
#ifdef DEBUG
printf("Disp: %x, But: %x, Font: %x x: %d, th: %d\n",
x11->disp, sc->but.self, x11->font, (int)x, th);
#endif
XResizeWindow(x11->disp, sc->but.self, (int)x-4, th-4);
nx = sqrt(sc->ncol);
ny = sc->ncol/nx;
while (nx*ny < sc->ncol)
{
ny++;
}
dx = ((float)x) / nx;
dy = ((float)y) / ny;
for (i = 0; (i < sc->ncol); i++)
{
X = x = (i%nx) * dx;
Y = y = (i/nx) * dy;
Dx = (int)(x+dx)-X;
Dy = (int)(y+dy)-Y;
XMoveWindow(x11->disp, sc->col[i].wd.self, X, th+Y);
XResizeWindow(x11->disp, sc->col[i].wd.self, Dx, Dy);
}
}
break;
}
return FALSE;
}
void move_man(t_x11 *x11, t_manager *man, int width, int height)
{
int x0, y0, mw, mh, hb;
int th;
#ifdef DEBUG
std::fprintf(stderr, "Move manager %dx%d\n", width, height);
#endif
man->wd.width = width;
man->wd.height = height;
/* Move all subwindows, resize only Mol window */
x0 = width-EWIDTH-AIR-4*BORDER; /* Starting of ewin etc. */
y0 = AIR;
/* Mol Window */
mw = x0-2*AIR-4*BORDER;
mh = height-y0-AIR-2*BORDER;
XMoveResizeWindow(x11->disp, man->molw->wd.self, AIR, y0, mw, mh);
/* Title Window */
th = XTextHeight(x11->font);
XMoveResizeWindow(x11->disp, man->title.self, 0, 0, mw, th+AIR);
/* Legend Window */
XMoveResizeWindow(x11->disp, man->legw->wd.self, x0, y0, EWIDTH, LEGHEIGHT);
y0 += LEGHEIGHT+AIR+2*BORDER;
if (y0 > height)
{
std::printf("Error: Windows falling out of main window!\n");
}
/* Button Box */
hb = height-y0-AIR-2*BORDER;
XMoveResizeWindow(x11->disp, man->bbox->wd.self, x0, y0, EWIDTH, hb);
/* Video Box */
x0 = (mw-man->vbox->wd.width)/2;
y0 = (mh-2-AIR-man->vbox->wd.height);
XMoveWindow(x11->disp, man->vbox->wd.self, x0, y0);
}
t_pulldown *init_pd(t_x11 *x11, Window Parent, int width,
unsigned long fg, unsigned long bg,
int nmenu, int *nsub, t_mentry *ent[], const char **title)
{
t_pulldown *pd;
int i;
snew(pd, 1);
pd->title = title;
pd->nmenu = nmenu;
pd->nsel = -1;
snew(pd->m, nmenu);
snew(pd->xpos, nmenu+1);
pd->xpos[0] = 5;
for (i = 1; (i <= nmenu); i++)
{
pd->xpos[i] = 20+pd->xpos[i-1]+
XTextWidth(x11->font, title[i-1], std::strlen(title[i-1]));
}
if (pd->xpos[nmenu] > width)
{
std::printf("Menu too wide\n");
}
InitWin(&(pd->wd), 0, 0, width, XTextHeight(x11->font)+2, 0, "PullDown");
pd->wd.self = XCreateSimpleWindow(x11->disp, Parent,
pd->wd.x, pd->wd.y,
pd->wd.width, pd->wd.height,
pd->wd.bwidth, fg, bg);
x11->RegisterCallback(x11, pd->wd.self, Parent, PDCallBack, pd);
x11->SetInputMask(x11, pd->wd.self, ExposureMask | ButtonPressMask |
OwnerGrabButtonMask | ButtonReleaseMask);
XMapWindow(x11->disp, pd->wd.self);
for (i = 0; (i < nmenu); i++)
{
pd->m[i] = init_menu(x11, Parent, fg, bg, nsub[i], ent[i], 1);
}
return pd;
}
static t_app *init_app(t_x11 *x11, int argc, char *argv[])
{
static const char *but_nm[ebutNR] = { "Quit", "Start", "Stop", "Rewind", "Toggle Gly" };
XSizeHints hints;
Pixmap pm;
int th;
t_app *app;
t_windata *wd;
int i, dx;
snew(app, 1);
th = XTextHeight(x11->font)+4;
InitWin(&(app->wd), 0, 0, MAXDEG+6, MAXDEG+6+th+6, 0, "Ramachandran Movie");
dx = app->wd.width/ebutNR;
app->wd.self = XCreateSimpleWindow(x11->disp, x11->root, app->wd.x, app->wd.y,
app->wd.width, app->wd.height,
app->wd.bwidth, x11->fg, x11->bg);
x11->RegisterCallback(x11, app->wd.self, x11->root, mainCallBack, app);
x11->SetInputMask(x11, app->wd.self, StructureNotifyMask);
hints.flags = 0;
pm = XCreatePixmapFromBitmapData(x11->disp, x11->root, (char *)rama_bits,
rama_width, rama_height, WHITE, BLACK, 1);
XSetStandardProperties(x11->disp, app->wd.self, app->wd.text,
"Rama", pm, argv, argc, &hints);
x11->RegisterCallback(x11, app->wd.self, x11->root, appCallBack, app);
x11->SetInputMask(x11, app->wd.self, ButtonPressMask | ExposureMask |
StructureNotifyMask);
app->xr = init_xrama(x11, app->wd.self, th+6, app);
for (i = 0; (i < ebutNR); i++)
{
wd = &(app->but[i]);
InitWin(wd, i*dx+2, 2, dx-4, th, 1, but_nm[i]);
wd->self = XCreateSimpleWindow(x11->disp, app->wd.self,
wd->x, wd->y, wd->width, wd->height,
wd->bwidth, x11->fg, x11->bg);
x11->RegisterCallback(x11, wd->self, app->wd.self, appCallBack, app);
x11->SetInputMask(x11, wd->self, ButtonPressMask | ExposureMask);
}
return app;
}
static void move_gmx(t_x11 *x11, t_gmx *gmx, int width, int height,
bool bSizePD)
{
int y0, wl, hl;
#ifdef DEBUG
fprintf(stderr, "Move gmx %dx%d\n", width, height);
#endif
y0 = XTextHeight(x11->font);
/* Resize PD-Menu */
if (bSizePD)
{
XResizeWindow(x11->disp, gmx->pd->wd.self, width, y0);
}
XMoveWindow(x11->disp, gmx->man->wd.self, 0, y0+1);
XResizeWindow(x11->disp, gmx->man->wd.self, width, height-y0-1);
wl = gmx->logo->wd.width;
hl = gmx->logo->wd.height;
XMoveWindow(x11->disp, gmx->logo->wd.self, (width-wl)/2, (height-y0-hl)/2);
}
t_butbox *init_vbox(t_x11 *x11, Window Parent, Window SendTo, unsigned long fg, unsigned long bg)
{
Pixmap pm;
unsigned char *data;
t_butbox *vb;
int i, ID, x, y0;
snew(vb, 1);
vb->nbut = IDNR-IDBUTNR-1;
snew(vb->b, vb->nbut);
/* VBox holder */
y0 = XTextHeight(x11->font)+2*AIR+2;
InitWin(&vb->wd, 0, 0, vb->nbut*(play_width+AIR)+AIR,
y0+play_height+2*AIR, 1, "VCR - Control");
vb->wd.self = XCreateSimpleWindow(x11->disp, Parent,
vb->wd.x, vb->wd.y, vb->wd.width, vb->wd.height,
vb->wd.bwidth, WHITE, BLACK);
x11->RegisterCallback(x11, vb->wd.self, Parent, VBCallBack, vb);
x11->SetInputMask(x11, vb->wd.self, ExposureMask);
x = AIR;
(void)CWBackPixmap;
for (i = 0; (i < vb->nbut); i++)
{
ID = IDBUTNR+i+1;
switch (ID)
{
case IDREWIND:
data = &(rewind_bits[0]);
break;
case IDSTEP:
data = play_bits;
break;
case IDFF:
data = ff_bits;
break;
case IDSTOP_ANI:
data = stop_ani_bits;
break;
default:
fprintf(stderr, "Invalid bitmap in init_vbox %d\n", ID);
exit(1);
}
/* Rely on the fact that all bitmaps are equal size */
pm = XCreatePixmapFromBitmapData(x11->disp, x11->root,
(char *)data, play_width, play_height,
BLACK, LIGHTGREY, x11->depth);
vb->b[i].ID = ID;
vb->b[i].wd.Parent = SendTo;
vb->b[i].wd.self =
XCreateSimpleWindow(x11->disp, vb->wd.self,
x, y0+AIR, play_width, play_height, 0, WHITE, BLACK);
XSetWindowBackgroundPixmap(x11->disp, vb->b[i].wd.self, pm);
x11->RegisterCallback(x11, vb->b[i].wd.self, vb->wd.self,
ButtonCallBack, &(vb->b[i]));
x11->SetInputMask(x11, vb->b[i].wd.self,
ButtonPressMask | StructureNotifyMask);
x += play_width+AIR;
}
return vb;
}
void DrawLoad(t_x11 *x11,t_windata *Win,int nloads,int *loadinfo)
{
static char *Strings[] = { "Unbalance","Single Node","Your Ad Here ?"};
int i,y0,bwidth,boff,bar,bmax,bmin,ym,yh;
int *lb;
real bav,bscale;
char maxstr[6];
return;
XClearWindow(x11->disp, Win->self);
y0=XTextHeight(x11->font)+AIR;
yh=(Win->height-y0)/2;
ym=y0+yh;
XSetForeground(x11->disp,x11->gc,WHITE);
XDrawLine(x11->disp,Win->self,x11->gc,0,y0,Win->width,y0);
if (nloads >= 2) {
TextInRect(x11,Win->self,Strings[0],AIR,0,Win->width-2*AIR,y0,
eXLeft,eYCenter);
if (loadinfo[0] == 0) {
nloads--;
lb=&loadinfo[1];
}
else {
lb=loadinfo;
if (loadinfo[nloads-1] == 0)
nloads--;
}
bwidth = (Win->width) / nloads;
boff = (Win->width % nloads)/2;
bav = 0.0;
bmax=bmin=lb[0];
for (i=1; (i<nloads); i++) {
bmax = max (bmax,lb[i]);
bmin = min (bmin,lb[i]);
bav += lb[i];
}
bav/=nloads;
bscale = (yh-2)/max(fabs(bmax-bav),fabs(bav-bmin));
sprintf(maxstr,"(%d%%)",(int)(100.0*(bmax-bav)/bav));
TextInRect(x11,Win->self,maxstr,AIR,0,Win->width-2*AIR,y0,
eXRight,eYCenter);
XDrawLine(x11->disp,Win->self,x11->gc,0,ym,Win->width,ym);
if (bmax-bmin) {
for(i=0; i<nloads; i++) {
bar=(lb[i]-bav)*bscale;
if (bar != 0) {
if (bar > 0)
XFillRectangle(x11->disp,Win->self,x11->gc,
(i*bwidth)+boff+1,ym-bar+1,bwidth-2,bar);
else
XFillRectangle(x11->disp,Win->self,x11->gc,
(i*bwidth)+boff+1,ym,bwidth-2,-bar);
}
}
}
}
else {
TextInRect(x11,Win->self,Strings[1],AIR,0,Win->width,y0,eXLeft,eYCenter);
TextInRect(x11,Win->self,Strings[2],AIR,y0,Win->width,
Win->height-y0,eXLeft,eYCenter);
}
XSetForeground(x11->disp,x11->gc,x11->fg);
}
t_menu *init_menu(t_x11 *x11,Window Parent,unsigned long fg,unsigned long bg,
int nent,t_mentry ent[],int ncol)
{
int i,mlen,mht,area,ht;
int j,k,l;
int frows,fcol;
t_menu *m;
t_child *kid;
t_windata *w;
snew(m,1);
m->nitem=nent;
m->Parent=Parent;
/* Calculate dimensions of the menu */
mlen=0;
for(i=0; (i<nent); i++)
mlen=max(mlen,XTextWidth(x11->font,ent[i].str,strlen(ent[i].str)));
mht=XTextHeight(x11->font);
/* Now we have the biggest single box, add a border of 2 pixels */
mlen+=20; /* We need extra space at the left for checkmarks */
mht+=4;
/* Calculate the area of the menu */
area=mlen*mht;
ht=sqrt(area);
/* No the number of rows per column, only beyond 8 rows */
if (ncol == 0) {
if (nent > 8)
frows=(1+ht/mht);
else
frows=nent;
fcol=nent/frows;
}
else {
fcol=ncol;
frows=nent/ncol;
if (nent % ncol)
frows++;
}
InitWin(&(m->wd),10,10,fcol*mlen,frows*mht,1,"Menu");
snew(m->item,nent);
m->wd.self=XCreateSimpleWindow(x11->disp,Parent,
m->wd.x, m->wd.y,
m->wd.width,m->wd.height,
m->wd.bwidth,fg,bg);
x11->RegisterCallback(x11,m->wd.self,Parent,MenuCallBack,m);
x11->SetInputMask(x11,m->wd.self,ExposureMask |
OwnerGrabButtonMask | ButtonReleaseMask);
for(j=l=0; (j<fcol); j++)
for(k=0; (k<frows) && (l<nent); k++,l++) {
kid=&(m->item[l]);
kid->m=&(ent[l]);
kid->Parent=Parent;
w=&(kid->wd);
InitWin(w,j*mlen,k*mht,mlen-2,mht-2,1,NULL);
w->self=XCreateSimpleWindow(x11->disp,m->wd.self,
w->x,w->y,w->width,w->height,
w->bwidth,bg,bg);
x11->RegisterCallback(x11,w->self,m->wd.self,
ChildCallBack,kid);
x11->SetInputMask(x11,w->self,
ButtonPressMask | ButtonReleaseMask |
OwnerGrabButtonMask | ExposureMask |
EnterWindowMask | LeaveWindowMask);
}
return m;
}
