int
main (void)
{
graphStruct *aGraph;
int keepLooking,code;
bsdSignal(SIGPIPE,brokenPipe,DontRestartSystemCalls);
#if defined(BSDplatform) || defined (MACOSXplatform)
bsdSignal(SIGCHLD,endChild,RestartSystemCalls);
#else
bsdSignal(SIGCLD,endChild,RestartSystemCalls);
#endif
bsdSignal(SIGTERM,goodbye,DontRestartSystemCalls);
/* Connect up to FriCAS server */
spadSock = connect_to_local_server(SpadServer,ViewportServer,Forever);
if (spadSock == NULL) {
fprintf(stderr,"The viewport manager couldn't connect to FriCAS\n");
exit(-1);
}
#ifdef DEBUG
else
fprintf(stderr,"viewman: Connected to FriCAS\n");
#endif
/******** initialize ********/
viewports = 0;
graphList = 0;
/******** getting stuff from spad and viewports ********
********* the viewports have priority over ****
*** FriCAS. ***/
while (1) {
FD_ZERO(&filedes); /* zero out file descriptor */
FD_SET(spadSock->socket,&filedes);
slot = viewports;
while (slot) {
FD_SET(slot->viewIn,&filedes);
slot = slot->nextViewport;
}
#ifdef DEBUG
fprintf(stderr,"Selection for filedes of %x \n",filedes);
#endif
code = check(superSelect(FD_SETSIZE,(void *) &filedes,0,0,0));
for (;code<=0;)
code = check(superSelect(FD_SETSIZE,(void *)&filedes,0,0,0));
slot = viewports;
keepLooking = 1;
while (keepLooking && slot) {
if (FD_ISSET(slot->viewIn,&filedes)) {
keepLooking = 0;
#ifdef DEBUG
fprintf(stderr,"Reading child viewport...\n");
#endif
viewCommand = viewportClosing;
readViewport(slot,&viewCommand,intSize);
switch (viewCommand) {
case pick2D:
#ifdef DEBUG
fprintf(stderr,"viewman: Doing 2D pick\n");
#endif
picked = yes;
readViewport(slot,¤tGraph,intSize); /* get the graph to pick */
readViewport(slot,¤tGraphState,sizeof(graphStateStruct));
break;
case drop2D:
#ifdef DEBUG
fprintf(stderr,"viewman: Doing 2D drop\n");
#endif
if (picked) {
write(slot->viewOut,&viewOkay,intSize);
write(slot->viewOut,¤tGraph,intSize);
sendGraphToView2D(0,currentGraph,slot,¤tGraphState);
} else {
write(slot->viewOut,&viewError,intSize);
fprintf(stderr,"The viewport manager cannot drop a graph because nothing has been picked yet.\n");
}
break;
case viewportClosing:
#ifdef DEBUG
fprintf(stderr,"viewman: closing viewport\n");
#endif
closeChildViewport(slot);
break;
}; /* switch */
}; /* if reading slot->viewIn */
stepSlot = slot;
slot = slot->nextViewport;
}; /* while */
if (keepLooking) { /* if 1 => slots not read, read from spad */
#ifdef DEBUG
fprintf(stderr,"viewman: still looking\n");
#endif
viewType = get_int(spadSock);
if (viewType == -1) goodbye(-1);
viewCommand = get_int(spadSock);
switch (viewType) {
case view3DType:
#ifdef DEBUG
fprintf(stderr,"viewman: making 3D viewport\n");
#endif
if (viewCommand == makeViewport)
forkView3D(view3DType);
else
funView3D(viewCommand);
break;
case viewTubeType:
#ifdef DEBUG
fprintf(stderr,"viewman: viewing a tube\n");
#endif
if (viewCommand == makeViewport)
forkView3D(viewTubeType);
else
funView3D(viewCommand);
break;
case viewGraphType:
#ifdef DEBUG
fprintf(stderr,"viewman: making a graph\n");
#endif
if (viewCommand == makeGraph) {
aGraph = makeGraphFromSpadData();
aGraph->nextGraph = graphList;
graphList = aGraph;
}
break;
case view2DType:
#ifdef DEBUG
fprintf(stderr,"viewman: forking 2D\n");
#endif
if (viewCommand == makeViewport) {
forkView2D();
} else {
funView2D(viewCommand);
}
break;
} /* switch on viewType */
} /* if (keepLooking) */
} /* while (1) */
}
void
forkView3D(int typeOfViewport)
{
viewManager *viewport;
int childPID, code;
int i;
view3DStruct doView3D;
int pipe0[2],pipe1[2];
int *anIndex;
char envAXIOM[100],runView[100];
int j,k;
LLPoint *anLLPoint;
LPoint *anLPoint;
#ifdef DEBUG
fprintf(stderr,"Pipe calls for 3D\n");
#endif
check(pipe(pipe0));
check(pipe(pipe1));
#ifdef DEBUG
fprintf(stderr,"Fork routine for 3D\n");
#endif
switch(childPID = check(fork())) {
case -1:
printf("Cannot create a new process - you probably have too many things running already.\n");
return;
case 0:
/*****************************
* child process *
*****************************/
/* map pipes from viewport manager to standard input and output */
#ifdef DEBUG
fprintf(stderr,"Mapping pipes to standard I/O in 3D\n");
#endif
check(dup2(pipe0[0],0));
check(dup2(pipe1[1],1));
close(pipe0[0]);
close(pipe0[1]);
close(pipe1[0]);
close(pipe1[1]);
#ifdef DEBUG
fprintf(stderr,"Executing ThreeDimensionalViewport process\n");
#endif
sprintf(envAXIOM,"%s",getenv("AXIOM"));
sprintf(runView,"%s%s",envAXIOM,"/lib/view3D");
check(execl(runView,runView,NULL));
fprintf(stderr,"The viewport manager could not execute view3D.\nCheck that view3D is on your PATH.\n");
exit(-1);
default:
/******************************
* parent process *
******************************/
if (!(viewport = (viewManager *)malloc(sizeof(viewManager)))) {
printf("Ran out of memory trying to create a new viewport process.\n");
return;
}
viewport->viewType = typeOfViewport;
viewport->PID = childPID;
/* set up pipes to child process */
close(pipe0[0]);
close(pipe1[1]);
viewport->viewIn = pipe1[0];
viewport->viewOut = pipe0[1];
/* add new viewport to global list */
viewport->nextViewport = viewports;
viewports = viewport;
if (viewport->viewIn <0) {
fprintf(stderr,
"The viewport manager could not create connection to a 3D viewport window. Try again.\n");
return;
} else {
code = readViewport(viewport,&acknow,intSize);
if (code < 0) {
fprintf(stderr,
"The viewport manager could not read from a 3D viewport window\ncode=%d\nack=%d\n",code,acknow);
return;
}
}
makeView3DFromSpadData(&doView3D,typeOfViewport);
/* tell the child that parent is a viewport manager */
i = no;
write(viewport->viewOut,&i,sizeof(int));
write(viewport->viewOut,&doView3D,sizeof(view3DStruct));
i = strlen(doView3D.title)+1;
write(viewport->viewOut,&i,intSize); /* tell the length of the title to child */
write(viewport->viewOut,doView3D.title,i); /* tell the title to the child */
write(viewport->viewOut,&(doView3D.lightVec[0]),floatSize);
write(viewport->viewOut,&(doView3D.lightVec[1]),floatSize);
write(viewport->viewOut,&(doView3D.lightVec[2]),floatSize);
/* send generalized 3D components */
write(viewport->viewOut,&(doView3D.numOfPoints),intSize);
for (i=0; i<doView3D.numOfPoints; i++) {
write(viewport->viewOut,&(refPt(doView3D,i)->x),floatSize);
write(viewport->viewOut,&(refPt(doView3D,i)->y),floatSize);
write(viewport->viewOut,&(refPt(doView3D,i)->z),floatSize);
write(viewport->viewOut,&(refPt(doView3D,i)->c),floatSize);
}
write(viewport->viewOut,&(doView3D.lllp.numOfComponents),intSize);
anLLPoint = doView3D.lllp.llp;
for (i=0; i<doView3D.lllp.numOfComponents; i++,anLLPoint++) {
write(viewport->viewOut,&(anLLPoint->prop.closed),intSize);
write(viewport->viewOut,&(anLLPoint->prop.solid),intSize);
write(viewport->viewOut,&(anLLPoint->numOfLists),intSize);
anLPoint = anLLPoint->lp;
for (j=0; j<anLLPoint->numOfLists; j++,anLPoint++) {
write(viewport->viewOut,&(anLPoint->prop.closed),intSize);
write(viewport->viewOut,&(anLPoint->prop.solid),intSize);
write(viewport->viewOut,&(anLPoint->numOfPoints),intSize);
anIndex = anLPoint->indices;
for (k=0; k<anLPoint->numOfPoints; k++,anIndex++)
write(viewport->viewOut,anIndex,intSize);
} /* for LPoints in LLPoints (j) */
} /* for LLPoints in LLLPoints (i) */
/*** get acknowledge from viewport */
code = readViewport(viewport,&(viewport->viewWindow),sizeof(Window));
sleep(1); /* wait a second...*/
send_int(spadSock,viewport->PID); /* acknowledge to spad */
} /* switch */
} /* forkView3D() */
void
funView3D(int viewCommand)
{
int code;
int viewPID;
float f1,f2,f3,f4;
int i1,i2;
viewManager *viewport;
viewPID = get_int(spadSock);
viewport = viewports;
while ((viewport) && (viewport->PID != viewPID))
viewport = viewport->nextViewport;
if (viewport) {
send_int(spadSock,1); /* acknowledge to spad */
viewmanEvent.xclient.window = viewport->viewWindow;
code = write(viewport->viewOut,&viewCommand,intSize);
switch (viewCommand) {
case rotate:
f1 = get_float(spadSock);
f2 = get_float(spadSock);
code = write(viewport->viewOut,&f1,floatSize);
code = write(viewport->viewOut,&f2,floatSize);
break;
case zoom:
f1 = get_float(spadSock);
code = write(viewport->viewOut,&f1,floatSize);
break;
case zoomx:
f1 = get_float(spadSock);
f2 = get_float(spadSock);
f3 = get_float(spadSock);
code = write(viewport->viewOut,&f1,floatSize);
code = write(viewport->viewOut,&f2,floatSize);
code = write(viewport->viewOut,&f3,floatSize);
break;
case translate:
f1 = get_float(spadSock);
f2 = get_float(spadSock);
code = write(viewport->viewOut,&f1,floatSize);
code = write(viewport->viewOut,&f2,floatSize);
break;
case modifyPOINT:
i1 = get_int(spadSock);
f1 = get_float(spadSock);
f2 = get_float(spadSock);
f3 = get_float(spadSock);
f4 = get_float(spadSock);
code = write(viewport->viewOut,&i1,intSize);
code = write(viewport->viewOut,&f1,floatSize);
code = write(viewport->viewOut,&f2,floatSize);
code = write(viewport->viewOut,&f3,floatSize);
code = write(viewport->viewOut,&f4,floatSize);
break;
case hideControl:
i1 = get_int(spadSock);
code = write(viewport->viewOut,&i1,intSize);
break;
case axesOnOff:
case perspectiveOnOff:
case region3D:
case clipRegionOnOff:
case clipSurfaceOnOff:
i1 = get_int(spadSock);
code = write(viewport->viewOut,&i1,intSize);
break;
case eyeDistanceData:
case hitherPlaneData:
f1 = get_float(spadSock);
code = write(viewport->viewOut,&f1,floatSize);
break;
case colorDef:
i1 = get_int(spadSock);
i2 = get_int(spadSock);
code = write(viewport->viewOut,&i1,intSize);
code = write(viewport->viewOut,&i2,intSize);
break;
case moveViewport:
i1 = get_int(spadSock);
i2 = get_int(spadSock);
code = write(viewport->viewOut,&i1,intSize);
code = write(viewport->viewOut,&i2,intSize);
break;
case resizeViewport:
i1 = get_int(spadSock);
i2 = get_int(spadSock);
code = write(viewport->viewOut,&i1,intSize);
code = write(viewport->viewOut,&i2,intSize);
break;
case transparent:
case opaqueMesh:
case render:
break;
case lightDef:
f1 = get_float(spadSock);
f2 = get_float(spadSock);
f3 = get_float(spadSock);
code = write(viewport->viewOut,&f1,floatSize);
code = write(viewport->viewOut,&f2,floatSize);
code = write(viewport->viewOut,&f3,floatSize);
break;
case translucenceDef:
f1 = get_float(spadSock);
code = write(viewport->viewOut,&f1,floatSize);
break;
case changeTitle:
s1 = get_string(spadSock);
i1 = strlen(s1);
code = write(viewport->viewOut,&i1,intSize);
code = write(viewport->viewOut,s1,i1);
break;
case writeView:
s1 = get_string(spadSock);
i1 = strlen(s1);
code = write(viewport->viewOut,&i1,intSize);
code = write(viewport->viewOut,s1,i1);
/* write out the types of things to be written */
i2 = get_int(spadSock);
code = write(viewport->viewOut,&i2,intSize);
while (i2) {
i2 = get_int(spadSock);
code = write(viewport->viewOut,&i2,intSize);
}
break;
case diagOnOff:
i1 = get_int(spadSock);
code = write(viewport->viewOut,&i1,intSize);
break;
case outlineOnOff:
i1 = get_int(spadSock);
code = write(viewport->viewOut,&i1,intSize);
break;
case spadPressedAButton:
i1 = get_int(spadSock);
code = write(viewport->viewOut,&i1,intSize);
break;
} /* switch */
/*** get acknowledge from viewport */
code = readViewport(viewport,&acknow,intSize);
send_int(spadSock,1); /* acknowledge to spad */
} else { /* if (viewport) */
send_int(spadSock,-1); /* send error value in acknowledge to spad */
}
}
void
rmViewMgr(viewManager *slotPtr)
{
int i,throwAway,code;
viewManager *somePort, *someOtherPort;
graphStruct *someGraph,*someOtherGraph; /* used in discarding graphs */
viewsWithThisGraph *someView,*someOtherView;
for (somePort=someOtherPort=viewports;
(somePort != 0) && (somePort != slotPtr);
somePort=(someOtherPort=somePort)->nextViewport)
{}
assert ((somePort == 0) ||
(somePort == viewports) ||
(somePort == someOtherPort->nextViewport));
if (somePort) {
if (somePort == viewports) viewports=viewports->nextViewport;
else someOtherPort->nextViewport = somePort->nextViewport;
}
/*** if view2D, then clean up after the graphs as well ***/
if (slotPtr->viewType == view2DType) {
for (i=0; i<maxGraphs; i++) {
code=readViewport(slotPtr,&throwAway,intSize); /* get the graph to discard */
if (code == -1) break; /* read failure - give up */
if (throwAway) { /* zero means no graph */
for (someGraph = someOtherGraph = graphList;
(someGraph != 0) && (someGraph->key != throwAway);
someGraph=(someOtherGraph=someGraph)->nextGraph)
{
}
/* someGraph is 0 if not found */
/* someGraph == graphList if found at first */
/* otherwise someGraph == someOtherGraph->nextGraph */
assert( (someGraph == 0) ||
(someGraph == graphList) ||
(someGraph == someOtherGraph->nextGraph));
if (someGraph) { /* if found (should always be true) */
for(someView=someOtherView=someGraph->views;
(someView !=0 ) && (someView->viewGr != slotPtr);
someView=(someOtherView=someView)->nextViewthing)
{
}
/* similarly */
assert( (someView == 0) ||
(someView == someGraph->views) ||
(someView == someOtherView->nextViewthing));
if (someView) { /* if found (should always be true) */
if (someView == someGraph->views)
/* first */
someGraph->views = someGraph->views->nextViewthing;
else
someOtherView->nextViewthing = someView->nextViewthing;
free(someView); /* remove this viewport
from list */
}
/* if now nothing is pointing to this graph , remove the graph from the list*/
if (someGraph->views == 0) {
if (someGraph == graphList)
graphList = graphList->nextGraph;
else
someOtherGraph->nextGraph = someGraph->nextGraph;
discardGraph(someGraph); /* free the graph */
}
} /* if someGraph */
} /* if throwAway */
} /* for i */
} /* if type is view2D */
close(slotPtr->viewIn);
close(slotPtr->viewOut);
free(slotPtr);
} /* rmViewMgr() */
