int sendtocon(char *pekare, int size)
{
struct IntuiMessage *mymess;
struct NiKMess *nikmess;
int aborted = FALSE, paused=FALSE;
ULONG signals,conwritesig = 1L << conwriteport->mp_SigBit,
conreadsig = 1L << conreadport->mp_SigBit,windsig = 1L << NiKwind->UserPort->mp_SigBit,
nikomnodesig = 1L << nikomnodeport->mp_SigBit;
char console = 1, tecken;
conwritereq->io_Command=CMD_WRITE;
conwritereq->io_Data=(APTR)pekare;
conwritereq->io_Length=size;
SendIO((struct IORequest *)conwritereq);
while(console)
{
signals = Wait(conwritesig | conreadsig | windsig | nikomnodesig);
if(signals & conwritesig) {
console=0;
if(WaitIO((struct IORequest *)conwritereq)) printf("Error console\n");
}
if(signals & conreadsig) {
if((tecken=congettkn()) == 3) {
if(console) {
AbortIO((struct IORequest *)conwritereq);
WaitIO((struct IORequest *)conwritereq);
}
aborted=TRUE;
console=0;
putstring("^C\n\r",-1,0);
} else if((tecken==' ' && (Servermem->inne[nodnr].flaggor & MELLANSLAG)) || tecken==19) paused=TRUE;
else if(tecken && typeaheadbuftkn<50) {
typeaheadbuf[typeaheadbuftkn++]=tecken;
typeaheadbuf[typeaheadbuftkn]=0;
}
}
if(signals & windsig) {
mymess=(struct IntuiMessage *)GetMsg(NiKwind->UserPort);
ReplyMsg((struct Message *)mymess);
cleanup(OK,"");
}
if(signals & nikomnodesig) {
while(nikmess = (struct NiKMess *) GetMsg(nikomnodeport)) {
handleservermess(nikmess);
ReplyMsg((struct Message *)nikmess);
}
if(carrierdropped()) aborted = TRUE;
}
}
if(paused && gettekn()==3)
{
putstring("^C\n\r",-1,0);
return(TRUE);
}
return(aborted);
}
// Clean up
void config_paths_cleanup(config_path_data *data)
{
if (data)
{
// AppWindow
RemoveAppWindow(data->appwindow);
// Close window
CloseConfigWindow(data->window);
// Free list
Att_RemList(data->path_list,0);
// Close cx library
/*#ifdef __amigaos4__
DropInterface((struct Interface *)ICommodities);
#endif
CloseLibrary(data->cxbase);*/
// Free port
if (data->appport)
{
struct Message *msg;
// Flush it
while ((msg=GetMsg(data->appport))) ReplyMsg(msg);
// Delete it
DeleteMsgPort(data->appport);
}
// Free data
FreeVec(data);
}
}
void rexx_exit (void)
{
if (ARexxPort) {
struct RexxMsg *msg;
gui_rexx_s *gui = &gui_rexx[ON_EXIT];
if (gui->port[0] && gui->cmd_on[0]) {
if (ADDRESS(gui->port, gui->cmd_on) != RC_OK) {
write_log ("%s:%s:%s\n", gui->port,
gui->cmd_on,
RESULT);
}
gui->port[0] = '\0';
}
Forbid ();
while ((msg = (struct RexxMsg*)GetMsg (ARexxPort))) {
msg->rm_Result1 = RC_ERROR;
msg->rm_Result2 = 0;
ReplyMsg ((void*)msg);
}
DeletePort (ARexxPort);
Permit ();
ARexxPort = NULL;
}
#ifdef __amigaos4__
if (IRexxSys) {
DropInterface ((struct Interface *)IRexxSys);
IRexxSys = NULL;
}
#endif
if (RexxSysBase) {
CloseLibrary ((void*)RexxSysBase);
RexxSysBase = NULL;
}
}
static void getevents(void)
{
struct IntuiMessage *msg;
while ((msg = (struct IntuiMessage *)GetMsg(win->UserPort)))
{
switch(msg->Class)
{
case IDCMP_CLOSEWINDOW:
Keys[KC_ESC] = 1;
break;
case IDCMP_RAWKEY:
{
WORD code = msg->Code & ~IECODE_UP_PREFIX;
Keys[code] = (code == msg->Code) ? 1 : 0;
}
break;
}
ReplyMsg((struct Message *)msg);
}
}
BOOL util_RemNamedObject(pUtility UtilBase, struct NamedObject *object, struct Message *message)
{
Forbid();
struct NameSpace *ns = SYSTEM(object)->no_Nos.nos_NameSpace;
if (ns == NULL)
{
if (message != NULL)
{
message->mn_Node.ln_Name = NULL;
ReplyMsg(message);
}
Permit();
return TRUE;
}
if (message == NULL)
{
if (SYSTEM(object)->no_Non.non_UseCount != 1)
{
Permit();
return TRUE;
}
}
SYSTEM(object)->no_Nos.nos_NameSpace = NULL;
ObtainSemaphore(&ns->ns_Semaphore);
Remove(&SYSTEM(object)->no_Non.non_Node);
if (message != NULL)
{
SYSTEM(object)->no_Nos.nos_RemoveMsg = message;
message->mn_Node.ln_Name = (STRPTR)object;
}
ReleaseSemaphore(&ns->ns_Semaphore);
Permit();
return ReleaseNamedObject(object);
}
void AXB_REG_FUNC DevBeginIO(AXB_REG(struct IOStdReq *ior,a1),
AXB_REG(struct DevBase *db,a6))
{
struct ExBase *eb = (struct ExBase *)db;
D(("DevBeginIO\n"));
ior->io_Error = 0;
ior->io_Flags &= ~IOF_QUICK;
switch(ior->io_Command)
{
case CMD_READ:
case CMD_WRITE:
/* forward message to worker process */
PutMsg(eb->eb_WorkerPort, &ior->io_Message);
break;
case CMD_RESET:
case CMD_UPDATE:
case CMD_CLEAR:
case CMD_STOP:
case CMD_START:
case CMD_FLUSH:
case CMD_INVALID:
default:
ior->io_Error = IOERR_NOCMD;
ReplyMsg(&ior->io_Message);
break;
}
}
void MainLoop(Object *win)
{
ULONG signals, portmask;
SetAttrs(win, MUIA_Window_Open, TRUE, TAG_END);
portmask = 1 << Port->mp_SigBit;
while (DoMethod(App, MUIM_Application_NewInput, (ULONG)&signals) != (ULONG)MUIV_Application_ReturnID_Quit)
{
if (signals)
{
signals = Wait(signals | portmask | SIGBREAKF_CTRL_C);
if (signals & portmask)
{
struct SysLogPacket *slp;
while (slp = (struct SysLogPacket*)GetMsg(Port))
{
if (slp->Level != LOG_CLOSE)
{
DoMethod(List, MUIM_List_InsertSingle, (ULONG)slp, MUIV_List_Insert_Bottom);
DoMethod(List, MUIM_List_Jump, MUIV_List_Jump_Bottom, TAG_END);
}
ReplyMsg(&slp->Msg);
}
}
if (signals & SIGBREAKF_CTRL_C) break;
}
}
SetAttrs(win, MUIA_Window_Open, FALSE, TAG_END);
return;
}
int main(int argc, char **argv)
{
int x, y;
if ((IntuitionBase = (struct IntuitionBase *) OpenLibrary("intuition.library", 0)))
{
if ((GfxBase = (struct GfxBase *)OpenLibrary("graphics.library", 0)))
{
if ((DOSBase = (struct DosLibrary *) OpenLibrary("dos.library",0)))
{
struct Window *w1;
w1 = openwindow(100, 100, 100, 100);
if (w1)
{
printf( "MoveWindow()...\n" );
for( x=0 ; x<50 ; x++ )
{
MoveWindow(w1,1,0);
// RefreshWindowFrame(w1);
}
for( y=0 ; y<50 ; y++ )
{
MoveWindow(w1,0,1);
// RefreshWindowFrame(w1);
}
printf( "ChangeWindowBox()...\n" );
for( x=0 ; x<50 ; x++ )
{
ChangeWindowBox(w1,150-x,150-x,100+x,100+x);
RefreshWindowFrame(w1);
}
printf( "SizeWindow()...\n" );
for( y=0 ; y<50 ; y++ )
{
SizeWindow(w1,-1,-1);
RefreshWindowFrame(w1);
}
printf( "Done!\nPress a key or click closegadget to quit.\n" );
Wait(1L<<w1->UserPort->mp_SigBit);
msg = (struct IntuiMessage *)GetMsg(w1->UserPort);
/* Catch any message to quit */
ReplyMsg((struct Message *)msg);
CloseWindow(w1);
}
CloseLibrary((struct Library *)DOSBase);
}
CloseLibrary((struct Library *)GfxBase);
}
CloseLibrary((struct Library *) IntuitionBase);
}
return 0;
} /* main */
// Reply or free a message
void LIBFUNC L_ReplyFreeMsg(REG(a0, struct Message *msg))
{
if (msg)
{
if (msg->mn_ReplyPort) ReplyMsg(msg);
else FreeVec(msg);
}
}
/*******************
** HandleEvents **
*******************/
VOID HandleEvents(struct Window *win, UBYTE *buffer, LONG bufsize)
{
struct IntuiMessage *imsg;
struct MsgPort *port = win->UserPort;
BOOL terminated = FALSE;
WORD written;
struct InputEvent ie ={0,};
ie.ie_Class = IECLASS_RAWKEY;
while (!terminated)
{
if ((imsg = (struct IntuiMessage *)GetMsg(port)) != NULL)
{
switch (imsg->Class)
{
case IDCMP_REFRESHWINDOW:
BeginRefresh(win);
EndRefresh(win, TRUE);
break;
case IDCMP_RAWKEY:
ie.ie_Code = imsg->Code;
ie.ie_Qualifier = imsg->Qualifier;
printf("rawkey: code=$%04x, qual=$%04x\n",
ie.ie_Code, ie.ie_Qualifier);
ie.ie_EventAddress = imsg->IAddress;
written = MapRawKey(&ie, buffer, bufsize, NULL);
if (written == -1)
printf("Buffer owerflow !!\n");
else if (written)
{
printf("Map:");
Write(Output(), buffer, written);
printf("\n");
}
if (ie.ie_Code == 197)
terminated = TRUE;
break;
} /* switch (imsg->Class) */
ReplyMsg((struct Message *)imsg);
} /* if ((imsg = GetMsg(port)) != NULL) */
else
{
Wait(1L << port->mp_SigBit);
}
} /* while (!terminated) */
return;
} /* HandleEvents() */
void SAVEDS handler(void)
{
struct Process *me = (struct Process *)FindTask(NULL);
struct startMsg *smsg;
struct MsgPort *port;
BOOL res = FALSE;
ENTER();
WaitPort(&me->pr_MsgPort);
smsg = (struct startMsg *)GetMsg(&me->pr_MsgPort);
#if defined(__amigaos4__)
port = AllocSysObject(ASOT_PORT, TAG_DONE);
#else
port = CreateMsgPort();
#endif
if(port != NULL)
res = localSendRexxMsg(port, smsg->port, smsg->cmd);
smsg->res = res;
ReplyMsg((struct Message *)smsg);
if(res == TRUE)
{
struct RexxMsg *rxmsg;
WaitPort(port);
rxmsg = (struct RexxMsg *)GetMsg(port);
DeleteArgstring((APTR)rxmsg->rm_Args[0]);
DeleteRexxMsg(rxmsg);
}
if(port != NULL)
{
#if defined(__amigaos4__)
FreeSysObject(ASOT_PORT, port);
#else
DeleteMsgPort(port);
#endif
}
ObtainSemaphore(&OpenURLBase->libSem);
OpenURLBase->rexx_use--;
ReleaseSemaphore(&OpenURLBase->libSem);
#if !defined(__amigaos4__)
// all systems except OS4 should leave this function in forbidden state
Forbid();
#endif
LEAVE();
}
static void Sys_Thread_Trampoline()
{
struct SysThread *thread;
thread = FindTask(0)->tc_UserData;
thread->entrypoint(thread->argument);
Forbid();
ReplyMsg(&thread->msg);
}
char gettekn(void)
{
struct IntuiMessage *mymess;
struct NiKMess *nikmess;
ULONG signals,conreadsig=1L << conreadport->mp_SigBit,windsig=1L << NiKwind->UserPort->mp_SigBit,
nikomnodesig = 1L << nikomnodeport->mp_SigBit;
char tkn=0,tmp[51];
if(typeaheadbuftkn)
{
tkn=typeaheadbuf[0];
strcpy(tmp,&typeaheadbuf[1]);
strcpy(typeaheadbuf,tmp);
typeaheadbuftkn--;
}
else
{
while(!tkn)
{
signals=Wait(conreadsig | windsig | nikomnodesig);
if(signals & conreadsig)
tkn=congettkn();
if(signals & windsig)
{
mymess=(struct IntuiMessage *)GetMsg(NiKwind->UserPort);
ReplyMsg((struct Message *)mymess);
cleanup(OK,"");
}
if(signals & nikomnodesig)
{
while(nikmess = (struct NiKMess *) GetMsg(nikomnodeport))
{
handleservermess(nikmess);
ReplyMsg((struct Message *)nikmess);
}
if(carrierdropped()) tkn = '\n';
}
}
}
return(tkn);
}
int commonsendrexx(int komnr,int hasarg) {
char rexxCmd[1081];
struct RexxMsg *nikrexxmess, *mess;
sendrexxrc = -5;
if(!hasarg) {
sprintf(rexxCmd, "NiKom:rexx/ExtKom%d %d %d", komnr, nodnr, inloggad);
} else {
sprintf(rexxCmd, "NiKom:rexx/ExtKom%d %d %d %s", komnr, nodnr, inloggad, argument);
}
if(!(nikrexxmess = (struct RexxMsg *) CreateRexxMsg(
rexxport, "nik", rexxport->mp_Node.ln_Name))) {
LogEvent(SYSTEM_LOG, ERROR, "Couldn't allocate a RexxMsg.");
return -5;
}
if(!(nikrexxmess->rm_Args[0] =
(STRPTR)CreateArgstring(rexxCmd,strlen(rexxCmd)))) {
DeleteRexxMsg(nikrexxmess);
LogEvent(SYSTEM_LOG, ERROR, "Couldn't allocate a rexx ArgString.");
return -5;
}
nikrexxmess->rm_Action = RXCOMM | RXFB_TOKEN;
if(!SafePutToPort((struct Message *)nikrexxmess, "REXX")) {
LogEvent(SYSTEM_LOG, ERROR, "Can't launch ARexx script, REXX port not found.");
return -5;
}
for(;;) {
mess = (struct RexxMsg *)WaitPort(rexxport);
while(mess = (struct RexxMsg *)GetMsg(rexxport)) {
if(mess->rm_Node.mn_Node.ln_Type == NT_REPLYMSG) {
DeleteArgstring(nikrexxmess->rm_Args[0]);
if(nikrexxmess->rm_Result1) {
LogEvent(SYSTEM_LOG, WARN, "Error return code %d from ARexx script: '%s'",
nikrexxmess->rm_Result1, rexxCmd);
SendString("\r\n\nError executing ARexx script.\r\n\n");
}
DeleteRexxMsg(nikrexxmess);
if(!rxlinecount) {
rxlinecount=TRUE;
radcnt = 0;
}
return sendrexxrc;
}
handleRexxCommand(mess->rm_Args[0], mess);
ReplyMsg((struct Message *)mess);
}
}
if(carrierdropped()) return(-8);
return(sendrexxrc);
}
STATIC VOID reply_async_request(struct x11_staticdata *xsd, void *primary_retval, int success)
{
xsd->hostclipboard_readstate = HOSTCLIPBOARDSTATE_IDLE;
REQ_SUCCESS(xsd->hostclipboardmsg) = success;
REQ_RETVAL(xsd->hostclipboardmsg) = (char *)primary_retval;
ReplyMsg(xsd->hostclipboardmsg);
xsd->hostclipboardmsg = NULL;
/* In case messages were sent, while an async request was in progress */
Signal(xsd->hostclipboardmp->mp_SigTask, 1L << xsd->hostclipboardmp->mp_SigBit);
}
int arexx_handle(void)
{
int retval = 0;
struct RexxMsg *msg;
while ((msg = (struct RexxMsg *)GetMsg(arexx_port)))
{
arexx_message(msg);
ReplyMsg((struct Message*)msg);
}
return retval;
}
VOID FlushUnit (struct DevUnit *unit, UBYTE last_queue, BYTE error, struct MyBase *base) {
struct IORequest *request;
UBYTE i;
struct Opener *opener, *tail;
/* Abort queued requests */
for (i = 0; i <= last_queue; i++) {
while ((request = (APTR)GetMsg (unit->request_ports [i])) != NULL) {
request->io_Error = IOERR_ABORTED;
ReplyMsg ((APTR)request);
}
}
#if 1
opener = (APTR)unit->openers.mlh_Head;
tail = (APTR)&unit->openers.mlh_Tail;
/* Flush every opener's read queue */
while (opener != tail) {
while ((request = (APTR)GetMsg (&opener->read_port)) != NULL) {
request->io_Error = error;
ReplyMsg ((APTR)request);
}
opener = (APTR)opener->node.mln_Succ;
}
#else
opener = request->ios2_BufferManagement;
while ((request = (APTR)GetMsg (&opener->read_port)) != NULL) {
request->io_Error = IOERR_ABORTED;
ReplyMsg ((APTR)request);
}
#endif
/* Return */
return;
}
BOOL util_ReleaseNamedObject(pUtility UtilBase, struct NamedObject *object)
{
if (!object) return TRUE;
Forbid();
SYSTEM(object)->no_Non.non_UseCount--;
if (SYSTEM(object)->no_Non.non_UseCount == 0)
{
if (SYSTEM(object)->no_Nos.nos_RemoveMsg != NULL) ReplyMsg(SYSTEM(object)->no_Nos.nos_RemoveMsg);
}
Permit();
return TRUE;
}
int getfifoevent(struct MsgPort *fifoport, char *puthere)
{
struct IntuiMessage *mymess;
struct NiKMess *nikmess;
ULONG signals,conreadsig=1L << conreadport->mp_SigBit,windsig=1L << NiKwind->UserPort->mp_SigBit,
fifosig=1L << fifoport->mp_SigBit, nikomnodesig = 1L << nikomnodeport->mp_SigBit;
int event=0;
while(!event) {
signals = Wait(conreadsig | windsig | fifosig | nikomnodesig | SIGBREAKF_CTRL_C);
if((signals & conreadsig) && CheckIO((struct IORequest *)conreadreq)) {
*puthere=congettkn();
event|=FIFOEVENT_FROMUSER;
}
if(signals & windsig) {
mymess=(struct IntuiMessage *)GetMsg(NiKwind->UserPort);
ReplyMsg((struct Message *)mymess);
AbortIO((struct IORequest *)conreadreq);
WaitIO((struct IORequest *)conreadreq);
event|=FIFOEVENT_CLOSEW;
}
if(signals & SIGBREAKF_CTRL_C) {
AbortIO((struct IORequest *)conreadreq);
WaitIO((struct IORequest *)conreadreq);
event|=FIFOEVENT_CLOSEW;
}
if(signals & fifosig) {
event|=FIFOEVENT_FROMFIFO;
}
if(signals & nikomnodesig) {
while(nikmess = (struct NiKMess *) GetMsg(nikomnodeport)) {
handleservermess(nikmess);
ReplyMsg((struct Message *)nikmess);
}
if(carrierdropped()) event |= FIFOEVENT_NOCARRIER;
}
}
return(event);
}
ULONG amigaGetTriggerSigs(void)
{
ULONG trigs = 0, sigr;
sigr = SetSignal(0L,0L);
if ( sigr & SIGBREAKF_CTRL_C ) trigs |= DNETC_MSG_SHUTDOWN;
#ifndef NO_GUI
if ( DnetcBase && ModeReqIsSet(-1) ) trigs |= dnetcguiHandleMsgs(sigr);
#endif
#ifndef __OS3PPC__
/*
** 68K / OS4 / MorphOS
*/
if ( TriggerPort && sigr & 1L << TriggerPort->mp_SigBit ) {
struct TriggerMessage *msg;
while ((msg = (struct TriggerMessage *)GetMsg(TriggerPort))) {
trigs |= msg->tm_TriggerType;
ReplyMsg((struct Message *)msg);
}
}
#elif !defined(__POWERUP__)
/*
** WarpOS
*/
if ( TriggerPort && sigr & 1L << TriggerPort->mp_Port.mp_SigBit ) {
struct TriggerMessage *msg;
while ((msg = (struct TriggerMessage *)GetMsgPPC(TriggerPort))) {
trigs |= msg->tm_TriggerType;
ReplyMsgPPC((struct Message *)msg);
}
}
#else
/*
** PowerUp
*/
{
void *msg;
while ((msg = PPCGetMessage(TriggerPort))) {
trigs |= PPCGetMessageAttr(msg,PPCMSGTAG_MSGID);
PPCReplyMessage(msg);
}
}
#endif
return(trigs);
}
static void do_thread (void)
{
struct Process *pr = (struct Process *) FindTask (NULL);
struct startupmsg *msg;
void *(*func) (void *);
void *arg;
WaitPort (&pr->pr_MsgPort);
msg = (struct startupmsg *) GetMsg(&pr->pr_MsgPort);
func = msg->func;
arg = msg->arg;
ReplyMsg ((struct Message*)msg);
func (arg);
}
static void handleall(void)
{
struct IntuiMessage *msg;
BOOL quitme = FALSE;
while(!quitme)
{
WaitPort(win->UserPort);
while ((msg = (struct IntuiMessage *)GetMsg(win->UserPort)))
{
switch(msg->Class)
{
case IDCMP_CLOSEWINDOW:
quitme = TRUE;
break;
case IDCMP_IDCMPUPDATE:
{
struct ColorWheelRGB rgb;
struct ColorWheelHSB hsb;
struct TagItem *tags = (struct TagItem *)msg->IAddress;
hsb.cw_Hue = GetTagData(WHEEL_Hue, 0, tags);
hsb.cw_Saturation = GetTagData(WHEEL_Saturation, 0, tags);
hsb.cw_Brightness = 0xFFFFFFFF;
ConvertHSBToRGB(&hsb, &rgb);
SetRGB32(vp, pen1, rgb.cw_Red, rgb.cw_Green, rgb.cw_Blue);
if (truecolor)
{
RefreshGList(gradgad, win, 0, 1);
}
}
break;
} /* switch(msg->Class) */
ReplyMsg((struct Message *)msg);
} /* while ((msg = (struct IntuiMessage *)GetMsg(win->UserPort))) */
} /* while(!quitme) */
}
VOID IPC_Dispatch( struct MsgPort * mPort )
{
struct IPCMsg * ipcmsg;
ENTER();
DBG_POINTER(mPort);
// get the next waiting message
while((ipcmsg = (struct IPCMsg *)GetMsg( mPort )))
{
DBG_VALUE(ipcmsg->ipc_ID);
if(ipcmsg->ipc_ID == IPC_MAGIC)
{
switch( ipcmsg->ipc_action )
{
case IPCA_INFOMSG:
iListInsert((STRPTR) ipcmsg->ipc_data );
ipcmsg->ipc_result = IPCR_OK;
break;
case IPCA_NZBFILE:
{
STRPTR nzbfile = (STRPTR) ipcmsg->ipc_data;
DBG_STRING(nzbfile);
if(Analyzer( nzbfile ))
ipcmsg->ipc_result = IPCR_OK;
else
ipcmsg->ipc_result = IPCR_FAIL;
} break;
case IPCA_DLSTATUS:
dlStatusReportHandler((struct dlStatus *)ipcmsg->ipc_data);
ipcmsg->ipc_result = IPCR_OK;
break;
default:
break;
}
}
ReplyMsg((APTR) ipcmsg );
}
LEAVE();
}
void rexx_handle_events (void)
{
struct RexxMsg *msg;
while ((msg = (struct RexxMsg*)GetMsg (ARexxPort))) {
if (!(msg->rm_Action & RXCOMM)) {
write_log ("Unknown action '%08X' recieved!\n",
msg->rm_Action);
continue;
}
msg->rm_Result1 = process_cmd (msg->rm_Args[0]);
msg->rm_Result2 = 0;
if (msg->rm_Action & RXFF_RESULT) {
int len = strlen (RESULT); /* holger: trick for powerup */
msg->rm_Result2 = (LONG)CreateArgstring (RESULT,len);
}
ReplyMsg ((void*)msg);
}
}
static void do_thread (void)
{
struct Process *pr = (struct Process *) FindTask (NULL);
struct startupmsg *msg;
void *(*func) (void *);
void *arg;
bug("[JUAE:PX] %s()\n", __PRETTY_FUNCTION__);
bug("[JUAE:PX] %s: task = %p\n", __PRETTY_FUNCTION__, pr);
WaitPort (&pr->pr_MsgPort);
msg = (struct startupmsg *) GetMsg(&pr->pr_MsgPort);
func = msg->func;
arg = msg->arg;
ReplyMsg ((struct Message*)msg);
func (arg);
}
ULONG handleevents(struct Window *win, struct Screen *screen, WORD x, WORD y)
{
struct IntuiMessage *imsg;
WORD y1;
struct MsgPort *port = win->UserPort;
BOOL terminated = FALSE;
ULONG retidcmp = 0;
while (!terminated)
{
if ((imsg = (struct IntuiMessage *)GetMsg(port)) != NULL)
{
switch (imsg->Class)
{
case IDCMP_CLOSEWINDOW:
terminated = TRUE;
break;
case IDCMP_INTUITICKS:
y1 = drawtext(win, x, y, "Screen position: (%d, %d) ", screen->LeftEdge, screen->TopEdge);
y1 = drawtext(win, x, y1, "Mouse position: (%d, %d) ", screen->MouseX, screen->MouseY);
y1 = drawtext(win, x, y1, "ViewPort size: %dx%d ", screen->ViewPort.DWidth, screen->ViewPort.DHeight);
y1 = drawtext(win, x, y1, "ViewPort position: (%d, %d) ", screen->ViewPort.DxOffset, screen->ViewPort.DyOffset);
y1 = drawtext(win, x, y1, "RasInfo position: (%d, %d) ", screen->ViewPort.RasInfo->RxOffset, screen->ViewPort.RasInfo->RyOffset);
y1 = drawtext(win, x, y1, "Window position: (%d, %d) ", win->LeftEdge, win->TopEdge);
drawtext(win, x, y1, "Window mouse position: (%d, %d) ",
win->MouseX, win->MouseY);
break;
} /* switch (imsg->Class) */
ReplyMsg((struct Message *)imsg);
} /* if ((imsg = GetMsg(port)) != NULL) */
else
{
Wait(1L << port->mp_SigBit);
}
} /* while (!terminated) */
return retidcmp;
} /* HandleEvents() */
int Loop()
{
pid_t pid;
int status;
while(link_count > 0)
{
pid = Receive(0, &msg, sizeof(msg));
if(pid == -1) {
if(errno != EINTR) {
Log("Receive() failed: [%d] %s", ERR(errno));
}
continue;
}
if(pid == IrqProxy()) {
while(Creceive(pid, 0, 0) == pid)
; // clear out any proxy overruns
add_interrupt_randomness(options.irq);
// Log("Irq: random size %d\n", get_random_size());
// now that we have more entropy...
SelectTrigger();
DoReadQueue();
continue;
}
status = Service(pid, &msg);
Log("Service() returned status %d (%s), link_count %d",
status, status == -1 ? "none" : strerror(status), link_count);
if(status >= EOK) {
msg.status = status;
ReplyMsg(pid, &msg, sizeof(msg.status));
}
}
return 0;
}
/*************
* DESCRIPTION: initialize a subtask and reply INIT message
* INPUT: -
* OUTPUT: subtask structure received from main task
*************/
struct SubTask *InitSubTask()
{
struct Process *me = (struct Process*)FindTask(NULL);
struct SubTask *st;
struct SubTaskMsg *stm;
BOOL done=FALSE;
// Wait for our startup message and ignore all other messages
while(!done)
{
WaitPort(&me->pr_MsgPort);
while((stm = (struct SubTaskMsg *)GetMsg(&me->pr_MsgPort)))
{
if(stm->stm_Command == STC_STARTUP)
{
done = TRUE;
break;
}
}
}
st = (struct SubTask *)stm->stm_Parameter;
st->st_Port = CreateMsgPort();
if(st->st_Port)
{
/*
** Reply startup message, everything ok.
** Note that if the initialization fails, the code falls
** through and replies the startup message with a stm_Result
** of 0 after a Forbid(). This tells the calling function that the
** sub task failed to run.
*/
stm->stm_Result = TRUE;
ReplyMsg((struct Message *)stm);
return(st);
}
ExitSubTask(st,stm);
return(NULL);
}
static void vsid_event_handling(void)
{
int done = 1;
unsigned long imCode, imClass;
struct IntuiMessage *imsg;
/* Check for IDCMP messages */
while ((imsg = (struct IntuiMessage *)GetMsg(vsid_window->UserPort))) {
imClass = imsg->Class;
imCode = imsg->Code;
switch (imClass) {
case IDCMP_MENUPICK:
pointer_to_default();
while (imCode != MENUNULL) {
struct MenuItem *n = ItemAddress(vsid_menu, imCode);
vsid_menu_handle((int)GTMENUITEM_USERDATA(n));
imCode = n->NextSelect;
}
vsid_menu_update();
done = 1;
break;
default:
break;
}
ReplyMsg((struct Message *)imsg);
switch (imClass) {
case IDCMP_CLOSEWINDOW:
do_quit_vice = 1;
break;
default:
break;
}
}
if (do_quit_vice) {
exit(0); // I think it's safe to quit here
}
}
/*************
* FUNCTION: ReplyRexxCommand
* VERSION: 0.1 08.03.1995
* DESCRIPTION: Sends a RexxMsg back to the rexx server, can include
* result codes
* INPUT: RexxMessage
* Primary primary result
* Secondary secondary result
* Result result string
* OUTPUT: none
* HISTORY: DATE NAME COMMENT
* 08.03.95 ah first release
*************/
VOID ReplyRexxCommand(struct RexxMsg *RexxMessage,LONG Primary,LONG Secondary,STRPTR Result)
{
/* Valid pointer given? */
if(RexxMessage && RexxMessage->rm_Node.mn_Node.ln_Type == NT_MESSAGE)
{
/* No secondary result and results wanted? */
if(Secondary == NULL && (RexxMessage->rm_Action & RXFF_RESULT))
{
/* Build result string... */
if(Result)
Secondary = (LONG)CreateArgstring((char *)Result,strlen((char *)Result));
}
/* Set both results... */
RexxMessage->rm_Result1 = Primary;
RexxMessage->rm_Result2 = Secondary;
/* ...and reply the message. */
ReplyMsg((struct Message *)RexxMessage);
}
}
