long huge_xfer(int fd, void huge *buf, unsigned sz, unsigned nel, int wr)
{
long nxfr=0, len=((long)sz) * ((long)nel);
char huge *xbuf = (char huge *)buf;
unsigned cur,cur1;
while (len>0) {
if (len>MAX_XFER)
cur=MAX_XFER;
else
cur=len;
if (wr)
cur1=sh_write(fd,(char *)xbuf,cur);
else
cur1=sh_read(fd,(char *)xbuf,cur);
if (cur1!=65535) {
len -= cur1;
nxfr += cur1;
xbuf = ((char huge *)buf) + nxfr;
/* not xbuf += cur1 due to bug in certain version of compiler */
}
if (cur1!=cur)
break;
}
return(nxfr);
}
int read_subs(void)
{
int f;
char s[81];
if(subboards)
farfree(subboards);
subboards=NULL;
max_subs=syscfg.max_subs;
subboards=(subboardrec *) mallocx(max_subs*sizeof(subboardrec), "subboards");
sprintf(s,"%sSUBS.DAT",syscfg.datadir);
f=sh_open1(s,O_RDONLY | O_BINARY);
if (f<0) {
printf("%s NOT FOUND.\n",s);
return(1);
}
num_subs=(sh_read(f,subboards, (max_subs*sizeof(subboardrec))))/
sizeof(subboardrec);
f=sh_close(f);
return(read_subs_xtr(max_subs, num_subs, subboards));
}
int open_sub(int wr)
{
postrec p;
if (sub_f>=0)
close_sub();
if (wr) {
sub_f = sh_open1(subdat_fn, O_RDWR|O_BINARY|O_CREAT);
if (sub_f>=0) {
/* re-read info from file, to be safe */
believe_cache = 0;
sh_lseek(sub_f, 0L, SEEK_SET);
sh_read(sub_f, &p, sizeof(postrec));
nummsgs=p.owneruser;
}
} else {
sub_f = sh_open1(subdat_fn, O_RDONLY|O_BINARY);
}
return(sub_f);
}
void add_post(postrec *pp)
{
postrec p;
int close_file=0;
/* open the sub, if necessary */
if (sub_f <= 0)
{
open_sub(1);
close_file=1;
}
if (sub_f>=0)
{
/* get updated info */
read_status();
sh_lseek(sub_f, 0L, SEEK_SET);
sh_read(sub_f, &p, sizeof(postrec));
/* one more post */
p.owneruser++;
nummsgs=p.owneruser;
sh_lseek(sub_f, 0L, SEEK_SET);
sh_write(sub_f, &p, sizeof(postrec));
/* add the new post */
sh_lseek(sub_f, ((long)nummsgs)*sizeof(postrec), SEEK_SET);
sh_write(sub_f, pp, sizeof(postrec));
/* we've modified the sub */
believe_cache=0;
subchg=0;
sub_dates[curlsub]=pp->qscan;
}
if (close_file)
close_sub();
}
void set_gat_section(int f, int section)
{
long l,l1;
int i;
if (gat_section!=section) {
l=filelength(f);
l1=((long)section)*GATSECLEN;
if (l<l1) {
chsize(f,l1);
l=l1;
}
sh_lseek(f,l1,SEEK_SET);
if (l<(l1+4096L)) {
for (i=0; i<2048; i++)
gat[i]=0;
sh_write(f,(void *)gat, 4096);
} else {
sh_read(f,(void *)gat, 4096);
}
gat_section=section;
}
}
int open_file(char *fn)
/* opens a WWIV Type-2 data file */
{
int f,i;
char s[81];
sprintf(s,"%s%s.DAT",syscfg.msgsdir,fn);
f=sh_open1(s,O_RDWR | O_BINARY);
if (f<0) {
f=sh_open(s,O_RDWR | O_BINARY | O_CREAT, S_IREAD | S_IWRITE);
for (i=0; i<2048; i++)
gat[i]=0;
sh_write(f,(void *)gat,4096);
strcpy(gatfn,fn);
/* chsize(f,4096L + (75L * 1024L)); */
}
if (strcmp(gatfn,fn)) {
sh_lseek(f,0L,SEEK_SET);
sh_read(f,(void *)gat,4096);
strcpy(gatfn,fn);
}
return(f);
}
void send_net_post(postrec *p, char *extra, int subnum)
{
net_header_rec nh, nh1;
char *b, *b1,s[81];
long len1, len2;
int f,i,onn,nn,n,nn1;
unsigned int *list;
xtrasubsnetrec *xnp;
if (extra[0]==0)
return;
b=readfile(&(p -> msg),extra,&len1);
if (b==NULL)
return;
onn=net_num;
if (p->status & status_post_new_net)
nn=p->title[80];
else if (xsubs[subnum].num_nets)
nn=xsubs[subnum].nets[0].net_num;
else
nn=net_num;
nn1=nn;
if (p->ownersys==0)
nn=-1;
nh1.tosys=0;
nh1.touser=0;
nh1.fromsys=p->ownersys;
nh1.fromuser=p->owneruser;
nh1.list_len=0;
nh1.daten=p->daten;
nh1.length=len1+1+strlen(p -> title);
nh1.method=0;
if (nh1.length > 32755) {
nh1.length = 32755;
len1=nh1.length-strlen(p->title)-1;
}
if ((b1=(char *)malloca(nh1.length+100))==NULL) {
farfree(b);
set_net_num(onn);
return;
}
strcpy(b1,p -> title);
memmove(&(b1[strlen(p -> title)+1]),b,(unsigned int) len1);
farfree(b);
for (n=0; n<xsubs[subnum].num_nets; n++) {
xnp=&(xsubs[subnum].nets[n]);
if ((xnp->net_num==nn) && (xnp->host))
continue;
set_net_num(xnp->net_num);
nh=nh1;
list=NULL;
nh.minor_type=xnp->type;
if (!nh.fromsys)
nh.fromsys=net_sysnum;
if (xnp->host) {
nh.main_type=main_type_pre_post;
nh.tosys=xnp->host;
} else {
nh.main_type=main_type_post;
sprintf(s,"%sN%s.NET",net_data, xnp->stype);
f=sh_open1(s,O_RDONLY|O_BINARY);
if (f>0) {
len1=filelength(f);
list=(unsigned int *)malloca(len1*2+1);
if (!list)
continue;
if ((b=(char *)malloca(len1+100L))==NULL) {
farfree(list);
continue;
}
sh_read(f,b,len1);
sh_close(f);
b[len1]=0;
len2=0;
while (len2<len1) {
while ((len2<len1) && ((b[len2]<'0') || (b[len2]>'9')))
++len2;
if ((b[len2]>='0') && (b[len2]<='9') && (len2<len1)) {
i=atoi(&(b[len2]));
if (((net_num!=nn) || (nh.fromsys!=i)) && (i!=net_sysnum))
list[(nh.list_len)++]=i;
while ((len2<len1) && (b[len2]>='0') && (b[len2]<='9'))
++len2;
}
}
farfree(b);
}
if (!nh.list_len) {
if (list)
farfree(list);
continue;
}
}
if (!xnp->type)
nh.main_type=main_type_new_post;
if (nn1==net_num)
send_net(&nh, list, b1, xnp->type?NULL:xnp->stype);
else
gate_msg(&nh, b1, xnp->net_num, xnp->stype, list, nn);
if (list)
farfree(list);
}
farfree(b1);
set_net_num(onn);
}
postrec *get_post(unsigned short mn)
/*
* Returns info for a post. Maintains a cache. Does not correct anything
* if the sub has changed.
*/
{
postrec p;
int close_file;
if (mn==0)
return(NULL);
if (subchg==1) {
/* sub has changed (detected in read_status); invalidate cache */
believe_cache=0;
/* kludge: subch==2 leaves subch indicating change, but the '2' value */
/* indicates, to this routine, that it has been handled at this level */
subchg=2;
}
/* see if we need new cache info */
if ((!believe_cache) ||
(mn<cache_start) ||
(mn>=(cache_start+MAX_TO_CACHE))) {
if (sub_f < 0) {
/* open the sub data file, if necessary */
if (open_sub(0)<0)
return(NULL);
close_file = 1;
} else {
close_file = 0;
}
/* re-read # msgs, if needed */
if (subchg==2) {
sh_lseek(sub_f, 0L, SEEK_SET);
sh_read(sub_f, &p, sizeof(postrec));
nummsgs=p.owneruser;
/* another kludge: subch==3 indicates we have re-read # msgs also */
/* only used so we don't do this every time through */
subchg=3;
/* adjust msgnum, if it is no longer valid */
if (mn>nummsgs)
mn=nummsgs;
}
/* select new starting point of cache */
if (mn >= last_msgnum) {
/* going forward */
if (nummsgs<=MAX_TO_CACHE)
cache_start=1;
else if (mn>(nummsgs-MAX_TO_CACHE))
cache_start=nummsgs-MAX_TO_CACHE+1;
else
cache_start = mn;
} else {
/* going backward */
if (mn>MAX_TO_CACHE)
cache_start = mn-MAX_TO_CACHE+1;
else
cache_start = 1;
}
if (cache_start<1)
cache_start=1;
/* read in some sub info */
sh_lseek(sub_f, ((long) cache_start)*sizeof(postrec), SEEK_SET);
sh_read(sub_f, cache, MAX_TO_CACHE*sizeof(postrec));
/* now, close the file, if necessary */
if (close_file) {
close_sub();
}
/* cache is now valid */
believe_cache = 1;
}
/* error if msg # invalid */
if ((mn<1) || (mn>nummsgs))
return(NULL);
last_msgnum=mn;
return(cache+(mn-cache_start));
}
char *readfile(messagerec *m1, char *aux, long *l)
/* reads a message from disk into memory */
{
int f,csec;
long l1,l2;
char *b,s[81],s1[81];
messagerec m;
setcbrk(0);
*l=0L;
m=*m1;
switch(m.storage_type) {
case 0:
case 1:
strcpy(s,syscfg.msgsdir);
ltoa(m.stored_as,s1,16);
if (m.storage_type==1) {
strcat(s,aux);
strcat(s,"\\");
}
strcat(s,s1);
f=sh_open1(s,O_RDONLY | O_BINARY);
if (f==-1) {
*l=0L;
return(NULL);
}
l1=filelength(f);
if ((b=(char *)farmalloc(l1))==NULL) {
sh_close(f);
return(NULL);
}
sh_read(f,(void *)b,l1);
sh_close(f);
*l=l1;
break;
case 2:
f=open_file(aux);
csec=m.stored_as;
l1=0;
while ((csec>0) && (csec<2048)) {
l1+=512L;
csec=gat[csec];
}
if (!l1) {
sh_close(f);
return(NULL);
}
if ((b=(char *)farmalloc(l1))==NULL) {
sh_close(f);
return(NULL);
}
csec=m.stored_as;
l1=0;
while ((csec>0) && (csec<2048)) {
sh_lseek(f,4096L + 512L*csec,SEEK_SET);
l1+=(long)read(f,(void *)(&(b[l1])),512);
csec=gat[csec];
}
sh_close(f);
l2=l1-512;
while ((l2<l1) && (b[l2]!=26))
++l2;
*l=l2;
break;
case 255:
f=sh_open1(aux,O_RDONLY | O_BINARY);
if (f==-1) {
*l=0L;
return(NULL);
}
l1=filelength(f);
if ((b=(char *)farmalloc(l1+256L))==NULL) {
sh_close(f);
return(NULL);
}
sh_read(f,(void *)b,l1);
sh_close(f);
*l=l1;
break;
default:
/* illegal storage type */
*l=0L;
b=NULL;
break;
}
return(b);
}
int iscan1(int si, int quick)
/*
* Initializes use of a sub value (subboards[], not usub[]). If quick, then
* don't worry about anything detailed, just grab qscan info.
*/
{
postrec p;
/* make sure we have cache space */
if (!cache) {
cache=malloca(MAX_TO_CACHE*sizeof(postrec));
if (!cache)
return(0);
}
/* forget it if an invalid sub # */
if ((si<0) || (si>=num_subs))
return(0);
/* skip this stuff if being called from the WFC cache code */
if (!quick) {
/* go to correct net # */
if (xsubs[si].num_nets)
set_net_num(xsubs[si].nets[0].net_num);
else
set_net_num(0);
/* see if a sub has changed */
read_status();
/* if already have this one set, nothing more to do */
if (si==currsub)
return(1);
}
currsub=si;
/* sub cache no longer valid */
believe_cache=0;
/* set sub filename */
sprintf(subdat_fn,"%s%s.SUB",syscfg.datadir,subboards[si].filename);
/* open file, and create it if necessary */
if (open_sub(0)<0) {
if (open_sub(1)<0)
return(0);
p.owneruser=0;
sh_write(sub_f,(void *) &p,sizeof(postrec));
}
/* set sub */
curlsub=si;
subchg=0;
last_msgnum=0;
/* read in first rec, specifying # posts */
sh_lseek(sub_f,0L,SEEK_SET);
sh_read(sub_f,&p, sizeof(postrec));
nummsgs=p.owneruser;
/* read in sub date, if don't already know it */
if (sub_dates[si]==0) {
if (nummsgs) {
sh_lseek(sub_f, ((long) nummsgs)*sizeof(postrec), SEEK_SET);
sh_read(sub_f, &p, sizeof(postrec));
sub_dates[si]=p.qscan;
} else {
sub_dates[si]=1;
}
}
/* close file */
close_sub();
/* iscanned correctly */
return(1);
}
void send_email2(void)
{
char s[81],scratch[81],log[81];
int f, i;
long len,len2;
char *b;
long thetime,dat;
int len3;
mailrec m,m1;
userrec ur;
messagerec msg;
struct date dt;
struct time tm;
char *month[] = {"Bug","Jan","Feb","Mar","Apr","May","Jun",
"Jul","Aug","Sep","Oct","Nov","Dec"};
m.touser=user_to_num;
time(&thetime);
len=(unsigned) strlen(buffer);
len2=len;
b=((char *)malloc(len+1024));
len=0;
sprintf(log,"þ Incoming mail for %s from %s (%s)\n",fido_to_user,fido_from_user,origi_node);
write_log(log);
sprintf(s,"%s (%s)",fido_from_user,origi_node);
addline(b,s,&len);
/* Get date/time of Email creation. */
/* Ditto the \015 for the time/date string. */
strncpy(scratch,fido_date_line,20);
scratch[20]='\0';
/* Build the date - cumbersome, but it needs to be done */
/* Build tblock as we go along so we can have a pretty date */
scratch[2] = '\0'; /* make day a string */
dt.da_day = atoi(scratch);
for (i=1;i<13;i++)
if (strncmpi(month[i],&scratch[3],3) == 0)
{
dt.da_mon = i;
break;
}
scratch[9] = '\0'; /* make year a string */
dt.da_year = atoi(&scratch[7]);
if (dt.da_year>90)
dt.da_year += 1900;
else
dt.da_year += 2000;
scratch[13] = '\0'; /* make hour a string */
tm.ti_hour = atoi(&scratch[11]);
scratch[16] = '\0'; /* make minute a string */
tm.ti_min = atoi(&scratch[14]);
scratch[19] = '\0'; /* make second a string */
tm.ti_sec = atoi(&scratch[17]);
tm.ti_hund = 0;
dat = dostounix(&dt,&tm);
strncpy(scratch,ctime(&(time_t)dat),24);
scratch[24]='\0';
strcat(scratch,"\r\n");
strcpy(s,scratch);
addline(b,s,&len);
strcat(b,buffer);
len += len2;
len=(unsigned) strlen(b);
if (b[len-1]!=26)
b[len++]=26;
m.msg.storage_type=2;
msg.stored_as=0L;
msg.storage_type=2;
savefile(b,len,&msg,"EMAIL");
m.msg=msg;
i=0;
strcpy(m.title,fido_title);
// i=strlen(m.title);
// m.title[i+1]=net_num;
// m.title[i+2]=0;
m.title[80]=net_num;
m.title[81]=0;
// i=0;
read_user(user_to_num,&ur);
++ur.waiting;
write_user(user_to_num,&ur);
lock_status();
save_status();
m.anony=i;
m.fromsys=atoi(wwiv_node);
m.fromuser=0;
m.tosys=0;
m.status=status_new_net;
time((long *)&(m.daten));
f=open_email(1);
len3=(int) filelength(f)/sizeof(mailrec);
if (len3==0)
i=0;
else
{
i=len3-1;
sh_lseek(f,((long) (i))*(sizeof(mailrec)), SEEK_SET);
sh_read(f,(void *)&m1,sizeof(mailrec));
while ((i>0) && (m1.tosys==0) && (m1.touser==0))
{
--i;
sh_lseek(f,((long) (i))*(sizeof(mailrec)), SEEK_SET);
sh_read(f,(void *)&m1,sizeof(mailrec));
}
if ((m1.tosys) || (m1.touser))
++i;
}
sh_lseek(f,((long) (i))*(sizeof(mailrec)), SEEK_SET);
sh_write(f,(void *)&m,sizeof(mailrec));
sh_close(f);
free(buffer);
}
void deletemsg(int mn)
{
postrec *p1, p;
int close_file=0;
unsigned int nb;
char *buf;
// char scratch[181];
long len, l, cp;
/* open file, if needed */
if (sub_f <= 0) {
open_sub(1);
close_file=1;
}
/* see if anything changed */
read_status();
if (sub_f >= 0) {
if ((mn>0) && (mn<=nummsgs)) {
buf=(char *)malloca(BUFSIZE);
if (buf) {
p1=get_post(mn);
remove_link(&(p1->msg),(subboards[curlsub].filename));
cp=((long)mn+1)*sizeof(postrec);
len=((long)(nummsgs+1))*sizeof(postrec);
do {
l=len-cp;
if (l<BUFSIZE)
nb=(int)l;
else
nb=BUFSIZE;
if (nb) {
sh_lseek(sub_f, cp, SEEK_SET);
sh_read(sub_f, buf, nb);
sh_lseek(sub_f, cp-sizeof(postrec), SEEK_SET);
sh_write(sub_f, buf, nb);
cp += nb;
}
} while (nb==BUFSIZE);
/* update # msgs */
sh_lseek(sub_f, 0L, SEEK_SET);
sh_read(sub_f, &p, sizeof(postrec));
p.owneruser--;
nummsgs=p.owneruser;
sh_lseek(sub_f, 0L, SEEK_SET);
sh_write(sub_f, &p, sizeof(postrec));
/* cache is now invalid */
believe_cache = 0;
bbsfree(buf);
}
}
}
/* close file, if needed */
if (close_file)
close_sub();
}
void
run()
{
/* Using Xlib event handling to use the keyboard helpers */
XEvent event;
fd_set fds;
struct timeval timeout;
struct timeval now;
uint32_t usec_sleep = 1000000 / config.HZ;
uint32_t usec_sleep_passive = 1000000 / config.HZ_passive;
int Xfd = XConnectionNumber(X.dpy);
/* If there is no user activity, we can spend more time between screen
* updates without the user feeling less responsiveness. Passive mode
* means that there are no X events to respond to, and we could slow down
* rendering a bit, offering more throughput
*/
struct timeval last_event;
last_event.tv_sec = 0;
last_event.tv_usec = 0;
bool passive = false;
for (;;) {
FD_ZERO(&fds);
FD_SET(Xfd, &fds);
FD_SET(shell_fd, &fds);
timeout.tv_sec = 0;
timeout.tv_usec = usec_sleep; /* TODO: set to blinking time? */
if (select(max(Xfd, shell_fd) + 1, &fds, NULL, NULL, &timeout) < 0) {
if (errno == EINTR)
continue;
die("select failed");
}
if (FD_ISSET(shell_fd, &fds)) {
sh_read(term_write); /* short circuit shell output and term input */
}
while (XPending(X.dpy)) {
XNextEvent(X.dpy, &event);
if (XFilterEvent(&event, X.window))
continue;
passive = false;
if (event.type < (int)LENGTH(x_handler) && x_handler[event.type])
(x_handler[event.type])(&event);
}
gettimeofday(&now, NULL);
if (timediff_usec(now, X.last_draw) > (passive ? usec_sleep_passive : usec_sleep)) {
x_draw();
}
if (FD_ISSET(Xfd, &fds)) {
gettimeofday(&last_event, NULL);
passive = false;
}
else {
passive = timediff_usec(now, last_event) > usec_sleep_passive;
}
if (!FD_ISSET(shell_fd, &fds) && passive) {
term_gc(); /* Clean up term if we have time to spare */
}
}
}
int esc_key_handler(void)
{
char c = 0; /* 读取字符 */
int ret = 0; /* 返回值 */
esc_read:
ret = sh_read(&c, 1);
if(ret <= 0)
{
/* 读取字符错误 */
c = 0;
goto esc_ret;
}
/* 继续读取字符 */
if (c == '[')
{
goto esc_read;
}
/* 将esc键值转换为控制字符 */
switch (c)
{
case 'A': /* UP */
c = CTRL('P');
break;
case 'B': /* DOWN */
c = CTRL('N');
break;
case 'C': /* RIGHT */
c = CTRL('F');
break;
case 'D': /* LEFT */
c = CTRL('B');
break;
case '3': /* DELETE */
ret = sh_read(&c, 1);
if(ret <= 0)
{
/* 读取字符错误 */
c = 0;
goto esc_ret;
}
if (c == '~')
{
c = VK_DELETE;
}
break;
default:
c = 0;
}
esc_ret:
return c;
}
static UWORD crysbind(WORD opcode, LONG pglobal, WORD control[], WORD int_in[], WORD int_out[], LONG addr_in[])
{
LONG maddr;
LONG tree;
WORD mouse, ret;
WORD unsupported = FALSE;
maddr = 0;
ret = TRUE;
switch(opcode)
{
/* Application Manager */
case APPL_INIT:
#if DBG_GEMSUPER
aestrace("appl_init()");
#endif
LWSET(pglobal, AES_VERSION); /* version number */
LWSET(pglobal+2, 0x0001); /* num of concurrent procs*/
/* LLSET(pglobal, 0x00010200L);
*/
LWSET(pglobal+4, rlr->p_pid);
sh_deskf(0, pglobal+6);
LWSET(pglobal+20, gl_nplanes);
LLSET(pglobal+22, ADDR(&D));
/* reset dispatcher */
/* count to let the app*/
/* run a while. */
dspcnt = 0;
ret = ap_init();
break;
case APPL_READ:
case APPL_WRITE:
ap_rdwr(opcode == APPL_READ ? MU_MESAG : MU_SDMSG,
fpdnm(NULLPTR, AP_RWID), AP_LENGTH, AP_PBUFF);
break;
case APPL_FIND:
ret = ap_find( AP_PNAME );
break;
case APPL_TPLAY:
ap_tplay(AP_TBUFFER, AP_TLENGTH, AP_TSCALE);
break;
case APPL_TRECORD:
ret = ap_trecd(AP_TBUFFER, AP_TLENGTH);
break;
#if CONF_WITH_PCGEM
case APPL_YIELD:
dsptch();
break;
#endif
case APPL_EXIT:
#if DBG_GEMSUPER
aestrace("appl_exit()");
#endif
ap_exit();
break;
/* Event Manager */
case EVNT_KEYBD:
ret = ev_block(MU_KEYBD, 0x0L);
break;
case EVNT_BUTTON:
ret = ev_button(B_CLICKS, B_MASK, B_STATE, &EV_MX);
break;
case EVNT_MOUSE:
ret = ev_mouse((MOBLK *)&MO_FLAGS, &EV_MX);
break;
case EVNT_MESAG:
#if DBG_GEMSUPER
aestrace("evnt_mesag()");
#endif
ap_rdwr(MU_MESAG, rlr, 16, ME_PBUFF);
break;
case EVNT_TIMER:
ev_timer( HW(T_HICOUNT) + LW(T_LOCOUNT) );
break;
case EVNT_MULTI:
#if DBG_GEMSUPER
aestrace("evnt_multi()");
#endif
if (MU_FLAGS & MU_TIMER)
maddr = HW(MT_HICOUNT) + LW(MT_LOCOUNT);
tree = HW(MB_CLICKS) | LW((MB_MASK << 8) | MB_STATE);
ret = ev_multi(MU_FLAGS, (MOBLK *)&MMO1_FLAGS, (MOBLK *)&MMO2_FLAGS,
maddr, tree, MME_PBUFF, &EV_MX);
break;
case EVNT_DCLICK:
ret = ev_dclick(EV_DCRATE, EV_DCSETIT);
break;
/* Menu Manager */
case MENU_BAR:
if (gl_mnppd == rlr || gl_mnppd == NULL)
mn_bar(MM_ITREE, SHOW_IT, rlr->p_pid);
else
menu_tree[rlr->p_pid] = (SHOW_IT) ? MM_ITREE : 0x0L;
break;
case MENU_ICHECK:
do_chg(MM_ITREE, ITEM_NUM, CHECKED, CHECK_IT, FALSE, FALSE);
break;
case MENU_IENABLE:
do_chg(MM_ITREE, (ITEM_NUM & 0x7fff), DISABLED,
!ENABLE_IT, ((ITEM_NUM & 0x8000) != 0x0), FALSE);
break;
case MENU_TNORMAL:
if (gl_mntree == menu_tree[rlr->p_pid])
do_chg(MM_ITREE, TITLE_NUM, SELECTED, !NORMAL_IT,
TRUE, TRUE);
break;
case MENU_TEXT:
tree = MM_ITREE;
strcpy((char *)LLGET(OB_SPEC(ITEM_NUM)),
(char *)MM_PTEXT);
break;
case MENU_REGISTER:
ret = mn_register(MM_PID, MM_PSTR);
break;
case MENU_UNREGISTER:
#if CONF_WITH_PCGEM
/* distinguish between menu_unregister() and menu_popup() */
if (IN_LEN == 1)
mn_unregister( MM_MID );
else
#endif
unsupported = TRUE;
break;
case MENU_CLICK:
/* distinguish between menu_click() and menu_attach() */
/*
* although menu_click() is PC-GEM only, it's always
* enabled because the desktop uses it.
*/
if (IN_LEN == 2) {
if (MN_SETIT)
gl_mnclick = MN_CLICK;
ret = gl_mnclick;
} else
unsupported = TRUE;
break;
/* Object Manager */
case OBJC_ADD:
ob_add(OB_TREE, OB_PARENT, OB_CHILD);
break;
case OBJC_DELETE:
ob_delete(OB_TREE, OB_DELOB);
break;
case OBJC_DRAW:
gsx_sclip((GRECT *)&OB_XCLIP);
ob_draw(OB_TREE, OB_DRAWOB, OB_DEPTH);
break;
case OBJC_FIND:
ret = ob_find(OB_TREE, OB_STARTOB, OB_DEPTH,
OB_MX, OB_MY);
break;
case OBJC_OFFSET:
ob_offset(OB_TREE, OB_OBJ, &OB_XOFF, &OB_YOFF);
break;
case OBJC_ORDER:
ob_order(OB_TREE, OB_OBJ, OB_NEWPOS);
break;
case OBJC_EDIT:
gsx_sclip(&gl_rfull);
OB_ODX = OB_IDX;
ret = ob_edit(OB_TREE, OB_OBJ, OB_CHAR, &OB_ODX, OB_KIND);
break;
case OBJC_CHANGE:
gsx_sclip((GRECT *)&OB_XCLIP);
ob_change(OB_TREE, OB_DRAWOB, OB_NEWSTATE, OB_REDRAW);
break;
/* Form Manager */
case FORM_DO:
ret = fm_do(FM_FORM, FM_START);
break;
case FORM_DIAL:
ret = fm_dial(FM_TYPE, (GRECT *)&FM_X);
break;
case FORM_ALERT:
ret = fm_alert(FM_DEFBUT, FM_ASTRING);
break;
case FORM_ERROR:
ret = fm_error(FM_ERRNUM);
break;
case FORM_CENTER:
ob_center(FM_FORM, (GRECT *)&FM_XC);
break;
case FORM_KEYBD:
gsx_sclip(&gl_rfull);
FM_OCHAR = FM_ICHAR;
FM_ONXTOB = FM_INXTOB;
ret = fm_keybd(FM_FORM, FM_OBJ, &FM_OCHAR, &FM_ONXTOB);
break;
case FORM_BUTTON:
gsx_sclip(&gl_rfull);
ret = fm_button(FM_FORM, FM_OBJ, FM_CLKS, &FM_ONXTOB);
break;
/* Graphics Manager */
case GRAF_RUBBOX:
gr_rubbox(GR_I1, GR_I2, GR_I3, GR_I4,
&GR_O1, &GR_O2);
break;
case GRAF_DRAGBOX:
gr_dragbox(GR_I1, GR_I2, GR_I3, GR_I4, (GRECT *)&GR_I5,
&GR_O1, &GR_O2);
break;
case GRAF_MBOX:
gr_movebox(GR_I1, GR_I2, GR_I3, GR_I4, GR_I5, GR_I6);
break;
case GRAF_GROWBOX:
gr_growbox((GRECT *)&GR_I1, (GRECT *)&GR_I5);
break;
case GRAF_SHRINKBOX:
gr_shrinkbox((GRECT *)&GR_I1, (GRECT *)&GR_I5);
break;
case GRAF_WATCHBOX:
ret = gr_watchbox(GR_TREE, GR_OBJ, GR_INSTATE, GR_OUTSTATE);
break;
case GRAF_SLIDEBOX:
ret = gr_slidebox(GR_TREE, GR_PARENT, GR_OBJ, GR_ISVERT);
break;
case GRAF_HANDLE:
GR_WCHAR = gl_wchar;
GR_HCHAR = gl_hchar;
GR_WBOX = gl_wbox;
GR_HBOX = gl_hbox;
ret = gl_handle;
break;
case GRAF_MOUSE:
if (GR_MNUMBER > 255)
{
if (GR_MNUMBER == M_OFF)
gsx_moff();
if (GR_MNUMBER == M_ON)
gsx_mon();
}
else
{
if (GR_MNUMBER != 255)
{
switch(GR_MNUMBER) {
case 1:
mouse = MICE01;
break;
case 2:
mouse = MICE02;
break;
case 3:
mouse = MICE03;
break;
case 4:
mouse = MICE04;
break;
case 5:
mouse = MICE05;
break;
case 6:
mouse = MICE06;
break;
case 7:
mouse = MICE07;
break;
default:
mouse = MICE00;
break;
}
maddr = *(LONG *) &rs_bitblk[mouse];
}
else
maddr = GR_MADDR;
gsx_mfset(maddr);
}
break;
case GRAF_MKSTATE:
gr_mkstate(&GR_MX, &GR_MY, &GR_MSTATE, &GR_KSTATE);
break;
/* Scrap Manager */
case SCRP_READ:
ret = sc_read((BYTE*)SC_PATH);
break;
case SCRP_WRITE:
ret = sc_write((const BYTE*)SC_PATH);
break;
#if CONF_WITH_PCGEM
case SCRP_CLEAR:
ret = sc_clear();
break;
#endif
/* File Selector Manager */
case FSEL_INPUT:
ret = fs_input((BYTE*)FS_IPATH, (BYTE*)FS_ISEL, &FS_BUTTON, NULL);
break;
case FSEL_EXINPUT:
ret = fs_input((BYTE*)FS_IPATH, (BYTE*)FS_ISEL, &FS_BUTTON, (BYTE *)FS_ILABEL);
break;
/* Window Manager */
case WIND_CREATE:
ret = wm_create(WM_KIND, (GRECT *)&WM_WX);
break;
case WIND_OPEN:
wm_open(WM_HANDLE, (GRECT *)&WM_WX);
break;
case WIND_CLOSE:
wm_close(WM_HANDLE);
break;
case WIND_DELETE:
wm_delete(WM_HANDLE);
break;
case WIND_GET:
wm_get(WM_HANDLE, WM_WFIELD, &WM_OX);
break;
case WIND_SET:
wm_set(WM_HANDLE, WM_WFIELD, &WM_IX);
break;
case WIND_FIND:
ret = wm_find(WM_MX, WM_MY);
break;
case WIND_UPDATE:
wm_update(WM_BEGUP);
break;
case WIND_CALC:
wm_calc(WM_WCTYPE, WM_WCKIND, WM_WCIX, WM_WCIY,
WM_WCIW, WM_WCIH, &WM_WCOX, &WM_WCOY,
&WM_WCOW, &WM_WCOH);
break;
case WIND_NEW:
wm_new();
break;
/* Resource Manager */
case RSRC_LOAD:
ret = rs_load(pglobal, RS_PFNAME);
break;
case RSRC_FREE:
ret = rs_free(pglobal);
break;
case RSRC_GADDR:
ret = rs_gaddr(pglobal, RS_TYPE, RS_INDEX, &ad_rso);
break;
case RSRC_SADDR:
ret = rs_saddr(pglobal, RS_TYPE, RS_INDEX, RS_INADDR);
break;
case RSRC_OBFIX:
rs_obfix(RS_TREE, RS_OBJ);
break;
/* Shell Manager */
case SHEL_READ:
sh_read((BYTE*)SH_PCMD, (BYTE*)SH_PTAIL);
break;
case SHEL_WRITE:
ret = sh_write(SH_DOEX, SH_ISGR, SH_ISCR, (const BYTE*)SH_PCMD, (const BYTE*)SH_PTAIL);
break;
case SHEL_GET:
sh_get((void*)SH_PBUFFER, SH_LEN);
break;
case SHEL_PUT:
sh_put((const void *)SH_PDATA, SH_LEN);
break;
case SHEL_FIND:
ret = sh_find((BYTE*)SH_PATH);
break;
case SHEL_ENVRN:
sh_envrn((BYTE**)SH_PATH, (const BYTE*)SH_SRCH);
break;
#if CONF_WITH_PCGEM
case SHEL_RDEF:
sh_rdef((BYTE*)SH_LPCMD, (BYTE*)SH_LPDIR);
break;
case SHEL_WDEF:
sh_wdef((const BYTE*)SH_LPCMD, (const BYTE*)SH_LPDIR);
break;
#endif
default:
unsupported = TRUE;
break;
}
if (unsupported) {
kprintf("Bad AES function %d\n", opcode);
if (opcode != 0) /* Ignore the 0 since some PRGs are this call */
fm_show(ALNOFUNC, &opcode, 1);
ret = -1;
}
return(ret);
}
