/* a procedure which tells my parent how to catch signals from its children */
void
catch_signals(void)
{
#ifdef siglog
sprintf(sigbuff, "/tmp/csig%d", getpid());
sigfile = open(sigbuff, O_RDWR | O_TRUNC | O_CREAT);
write(sigfile, "Started \n", strlen("Started \n"));
close(sigfile);
#endif
bsdSignal(SIGHUP, hangup_handler,RestartSystemCalls);
bsdSignal(SIGCHLD,child_handler,RestartSystemCalls);
bsdSignal(SIGTERM, terminate_handler,RestartSystemCalls);
bsdSignal(SIGINT, interrupt_handler,RestartSystemCalls);
bsdSignal(SIGALRM, alarm_handler,RestartSystemCalls);
alarm(60);
}
int
main(void)
{
sock = connect_to_local_server(SessionServer, InterpWindow, Forever);
bsdSignal(SIGINT, inter_handler,RestartSystemCalls);
remote_stdio(sock);
return(0);
}
void
ht2_input(void)
{
HashTable *table;
HashEntry *entry;
int i;
bsdSignal(SIGUSR2, SIG_IGN,RestartSystemCalls);
gWindow = alloc_hd_window();
init_group_stack();
table = gWindow->fPageHashTable;
make_input_file_list();
for (i = 0; i < table->size; i++)
for (entry = table->table[i]; entry != NULL; entry = entry->next)
make_the_input_file((UnloadedPage *) entry->data);
if (kill_spad){
i = connect_spad();
if (i != NotConnected && i != SpadBusy)
send_int(spad_socket, KillLispSystem);
}
}
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) */
}
static void
sman_catch_signals(void)
{
/* Set up the signal handlers for sman */
bsdSignal(SIGINT, SIG_IGN,RestartSystemCalls);
bsdSignal(SIGTERM, death_handler,RestartSystemCalls);
bsdSignal(SIGQUIT, death_handler,RestartSystemCalls);
bsdSignal(SIGHUP, death_handler,RestartSystemCalls);
bsdSignal(SIGILL, death_handler,RestartSystemCalls);
bsdSignal(SIGTRAP, death_handler,RestartSystemCalls);
#ifdef SIGABRT
bsdSignal(SIGABRT, death_handler,RestartSystemCalls);
#else
#ifdef SIGIOT
bsdSignal(SIGIOT, death_handler,RestartSystemCalls);
#endif
#endif
bsdSignal(SIGBUS, death_handler,RestartSystemCalls);
bsdSignal(SIGSEGV, death_handler,RestartSystemCalls);
/* don't restart wait call on SIGUSR1 */
bsdSignal(SIGUSR1, nagman_handler,DontRestartSystemCalls);
/* ONLY nagman should send this.
If an error (such as C-c) interrupts a NAGLINK call, nagman
gets a signal to clean up. We need to start another nagman
almost immediately to process the next NAGLINK request.
Since nagman takes a while to clean up, we treat it specially.
nagman should send a signal (USR1) to sman.
sman should respond by spawning a new nagman.
so nagman is NOT a DoItAgain but a NadaDelShitsky.
The USR1 mechanism does not work for HPUX 9 - use DoItAgain
*/
}
/* client Spad server sockets. Two sockets are created: server[0]
is the internet server socket, and server[1] is a local domain socket. */
int
open_server(char *server_name)
{
char *s, name[256];
init_socks();
#ifndef HAVE_MSG_NOSIGNAL
#ifdef SIGPIPE
bsdSignal(SIGPIPE, sigpipe_handler,RestartSystemCalls);
#endif
#endif
if (make_server_name(name, server_name) == -1)
return -2;
/* create the socket internet socket */
server[0].socket = 0;
/* server[0].socket = fricas_communication_link(AF_INET);
if (is_invalid_socket(&server[0])) {
server[0].socket = 0;
} else {
server[0].addr.i_addr.sin_family = AF_INET;
server[0].addr.i_addr.sin_addr.s_addr = INADDR_ANY;
server[0].addr.i_addr.sin_port = 0;
if (bind(server[0].socket, &server[0].addr.i_addr,
sizeof(server[0].addr.i_addr))) {
perror("binding INET stream socket");
server[0].socket = 0;
return -1;
}
length = sizeof(server[0].addr.i_addr);
if (getsockname(server[0].socket, &server[0].addr.i_addr, &length)) {
perror("getting INET server socket name");
server[0].socket = 0;
return -1;
}
server_port = ntohs(server[0].addr.i_addr.sin_port);
FD_SET(server[0].socket, &socket_mask);
FD_SET(server[0].socket, &server_mask);
listen(server[0].socket,5);
} */
/* Next create the local domain socket */
server[1].socket = fricas_communication_link(FRICAS_AF_LOCAL);
if (is_invalid_socket(&server[1])) {
perror("opening local server socket");
server[1].socket = 0;
return -2;
} else {
server[1].addr.u_addr.sa_family = FRICAS_AF_LOCAL;
memset(server[1].addr.u_addr.sa_data, 0,
sizeof(server[1].addr.u_addr.sa_data));
strcpy(server[1].addr.u_addr.sa_data, name);
if (bind(server[1].socket, &server[1].addr.u_addr,
sizeof(server[1].addr.u_addr))) {
perror("binding local server socket");
server[1].socket = 0;
return -2;
}
FD_SET(server[1].socket, &socket_mask);
FD_SET(server[1].socket, &server_mask);
listen(server[1].socket, 5);
}
s = getenv("SPADSERVER");
if (s == NULL) {
/* fprintf(stderr, "Not a spad server system\n"); */
return -1;
}
return 0;
}
int
main(int argc, char **argv)
{
int ret_status;
/* Initialize some global values */
/* fprintf(stderr,"hyper:main:entered\n");*/
gArgc = argc;
gArgv = argv;
gIsEndOfOutput = 1;
/* fprintf(stderr,"hyper:main:calling check_arguments\n");*/
check_arguments();
/* fprintf(stderr,"hyper:main:returned check_arguments\n");*/
/*
* initialize the hash tables for the files and the windows and images
*/
/* fprintf(stderr,"hyper:main:calling init_hash\n");*/
init_hash();
/* fprintf(stderr,"hyper:main:returned init_hash\n");*/
/*
* initialize the parser keyword hash table
*/
/* fprintf(stderr,"hyper:main:calling parser_init\n");*/
parser_init();
/* fprintf(stderr,"hyper:main:returned parser_init\n");*/
/* fprintf(stderr,"hyper:main:calling read_ht_db\n");*/
read_ht_db(&init_page_hash, &init_macro_hash, &init_patch_hash);
/* fprintf(stderr,"hyper:main:returned read_ht_db\n");*/
/*
* Now initialize x. This includes opening the display, setting the
* screen and display global values, and also gets all the fonts and
* colors we will need.
*/
if (!make_input_file && !gmake_record_file && !gverify_record_file) {
/* fprintf(stderr,"hyper:main:calling initializeWindowSystem\n");*/
initializeWindowSystem();
/* fprintf(stderr,"hyper:main:returned initializeWindowSystem\n");*/
/*
* Initialize some of the global values used by the input string
* routines
*/
/* fprintf(stderr,"hyper:main:calling init_keyin\n");*/
init_keyin();
/* fprintf(stderr,"hyper:main:returned init_keyin\n");*/
/*
* regardless of what else happened, we should always pop up an
* initial window.
*/
/* fprintf(stderr,"hyper:main:calling init_top_window\n");*/
ret_status = init_top_window("RootPage");
/* fprintf(stderr,"hyper:main:returned init_top_window\n");*/
gParentWindow = gWindow;
if (ret_status == -1) {
fprintf(stderr,
"(HyperDoc) Could not find RootPage for top-level window.\n");
exit(-1);
}
/*
* Tell it how to handle the user defined signals I may get
*/
bsdSignal(SIGUSR2, sigusr2_handler,RestartSystemCalls);
bsdSignal(SIGUSR1, SIG_IGN,RestartSystemCalls);
#if defined(BSDplatform) || defined(MACOSXplatform)
bsdSignal(SIGCHLD, sigcld_handler,RestartSystemCalls);
#else
bsdSignal(SIGCLD, sigcld_handler,RestartSystemCalls);
#endif
bsdSignal(SIGINT, SIG_IGN,RestartSystemCalls);
/*
* Now go to the main event loop. I will never return, so just end
* the main routine after that
*/
/*
* make an input file if requested
*/
}
else {
/*
* Try to establish all the socket connections I need. If I am an
* is_fricas_server and the routine fails, it will exit for me
*/
/* fprintf(stderr,"hyper:main:in else case\n");*/
/* fprintf(stderr,"hyper:main:calling make_server_connections\n");*/
make_server_connections();
/* fprintf(stderr,"hyper:main:returned make_server_connections\n");*/
if (make_input_file) ht2_input();
if (gmake_record_file) make_record();
if (gverify_record_file) verify_record();
exit(0);
}
/*
* Try to establish all the socket connections I need. If I am an
* is_fricas_server and the routine fails, it will exit for me
*/
/* fprintf(stderr,"hyper:main:calling make_server_connections\n");*/
make_server_connections();
/* fprintf(stderr,"hyper:main:returned make_server_connections\n");*/
/* fprintf(stderr,"hyper:main:calling mainEventLoop\n");*/
mainEventLoop();
/* fprintf(stderr,"hyper:main:returned mainEventLoop\n");*/
return 0;
}
void
handle_function_key(int key,int chann)
{
/** this procedure simply adds the string specified by the function key
to the buffer ****/
int count, fd;
int amount = strlen(function_key[key].str);
int id;
int save_echo;
/*** This procedure takes the character at in_buff[num_proc] and adds
it to the buffer. It first checks to see if we should be inserting
or overwriting, and then does the appropriate thing *******/
switch ((function_key[key]).type) {
case IMMEDIATE:
if (INS_MODE) {
forwardcopy(&buff[curr_pntr + amount],
&buff[curr_pntr],
buff_pntr - curr_pntr);
forwardflag_cpy(&buff_flag[curr_pntr + amount],
&buff_flag[curr_pntr],
buff_pntr - curr_pntr);
for (count = 0; count < amount; count++) {
buff[curr_pntr + count] = (function_key[key].str)[count];
buff_flag[curr_pntr + count] = '1';
}
ins_print(curr_pntr, amount + 1);
buff_pntr = buff_pntr + amount;
}
else {
for (count = 0; count < amount; count++) {
buff[curr_pntr + count] = (function_key[key].str)[count];
buff_flag[curr_pntr + count] = '1';
myputchar((function_key[key].str)[count]);
}
}
num_proc = num_proc + 6;
curr_pntr = curr_pntr + amount;
buff_pntr = buff_pntr + amount;
send_function_to_child();
break;
case DELAYED:
if (INS_MODE) {
forwardcopy(&buff[curr_pntr + amount],
&buff[curr_pntr],
buff_pntr - curr_pntr);
forwardflag_cpy(&buff_flag[curr_pntr + amount],
&buff_flag[curr_pntr],
buff_pntr - curr_pntr);
for (count = 0; count < amount; count++) {
buff[curr_pntr + count] = (function_key[key].str)[count];
buff_flag[curr_pntr + count] = '1';
}
ins_print(curr_pntr, amount + 1);
buff_pntr = buff_pntr + amount;
}
else {
for (count = 0; count < amount; count++) {
buff[curr_pntr + count] = (function_key[key].str)[count];
buff_flag[curr_pntr + count] = '1';
myputchar((function_key[key].str)[count]);
}
}
num_proc = num_proc + 6;
curr_pntr = curr_pntr + amount;
buff_pntr = buff_pntr + amount;
fflush(stdout);
break;
case SPECIAL:
/* fprintf(stderr, "Here I am \n"); */
if (access(editorfilename, F_OK) < 0) {
fd = open(editorfilename, O_RDWR | O_CREAT, 0666);
write(fd, buff, buff_pntr);
back_up(buff_pntr);
close(fd);
}
else {
if (buff_pntr > 0) {
fd = open(editorfilename, O_RDWR | O_TRUNC);
write(fd, buff, buff_pntr);
back_up(buff_pntr);
close(fd);
}
}
#if defined(MACOSXplatform) || defined(BSDplatform)
bsdSignal(SIGCHLD, null_fnct,RestartSystemCalls);
#else
bsdSignal(SIGCLD, null_fnct,RestartSystemCalls);
#endif
switch (id = fork()) {
case -1:
perror("Special key");
break;
case 0:
execlp((function_key[12]).str,
(function_key[12]).str,
editorfilename, NULL);
perror("Returned from exec");
exit(0);
}
while (wait((int *) 0) < 0);
/** now I should read that file and send all it stuff thru the
reader *****/
fd = open(editorfilename, O_RDWR);
if (fd == -1) {
perror("Opening temp file");
exit(-1);
}
num_proc += 6;
/** reinitialize the buffer ***/
init_flag(buff_flag, buff_pntr);
init_buff(buff, buff_pntr);
/** reinitialize my buffer pointers **/
buff_pntr = curr_pntr = 0;
/** reset the ring pointer **/
current = NULL;
save_echo = ECHOIT;
ECHOIT = 0;
while ((num_read = read(fd, in_buff, MAXLINE))) {
do_reading();
}
close(fd);
break;
}
return;
}
int
main(void)
{
XGCValues controlGCVals;
int i,code;
view2DStruct viewData;
char property[256];
char *prop = &property[0];
char *str_type[20];
XrmValue value;
/**** Set up display ****/
if ((dsply = XOpenDisplay(getenv("DISPLAY"))) == NULL)
fprintf(stderr,"Could not open the display.\n");
scrn = DefaultScreen(dsply);
rtWindow = RootWindow(dsply,scrn);
/**** link Xwindows to viewports - X10 feature ****/
table = XCreateAssocTable(nbuckets);
/**** Create FriCAS color map ****/
totalColors = XInitSpadFill(dsply,scrn,&colorMap,
&totalHues,&totalSolidShades,
&totalDitheredAndSolids,&totalShades);
if (totalColors < 0) {
fprintf(stderr,">>Error: Could not allocate all the necessary colors.\n");
exitWithAck(RootWindow(dsply,scrn),Window,-1);
}
mergeDatabases();
/*** Determine whether monochrome or color is used ***/
if (XrmGetResource(rDB,"Axiom.2D.monochrome","",str_type,&value) == True)
(void) strncpy(prop,value.addr,(int)value.size);
else
(void) strcpy(prop, "off");
mono = ((totalSolid == 2) || (strcmp(prop,"on") == 0));
if (XrmGetResource(rDB,"Axiom.2D.inverse","",str_type,&value) == True)
(void) strncpy(prop,value.addr,(int)value.size);
else
(void) strcpy(prop, "off");
if (mono)
if (strcmp(prop,"on") == 0) { /* 0 if equal (inverse video) */
foregroundColor = WhitePixel(dsply,scrn);
backgroundColor = BlackPixel(dsply,scrn);
} else { /* off (no inverse video) */
foregroundColor = BlackPixel(dsply,scrn);
backgroundColor = WhitePixel(dsply,scrn);
}
else /* inverse of inverse in color (for some strange reason) */
if (strcmp(prop,"on") == 0) { /* 0 if equal (inverse video) */
foregroundColor = WhitePixel(dsply,scrn);
backgroundColor = BlackPixel(dsply,scrn);
} else { /* off (no inverse video) */
foregroundColor = BlackPixel(dsply,scrn);
backgroundColor = WhitePixel(dsply,scrn);
}
/* read default file name for postScript output */
if (XrmGetResource(rDB,
"Axiom.2D.postscriptFile",
"",
str_type, &value) == True)
(void) strncpy(prop,value.addr,(int)value.size);
else
(void) strcpy(prop, "axiom2D.ps");
PSfilename = (char *)malloc(strlen(prop)+1);
strcpy(PSfilename,prop);
/**** Open global fonts ****/
serverFont = XQueryFont(dsply,XGContextFromGC(DefaultGC(dsply,scrn)));
if (XrmGetResource(rDB,
"Axiom.2D.messageFont",
"Axiom.2D.Font",
str_type, &value) == True)
(void) strncpy(prop,value.addr,(int)value.size);
else
(void) strcpy(prop,messageFontDefault);
if ((globalFont = XLoadQueryFont(dsply, prop)) == NULL) {
fprintf(stderr,
"Warning: could not get the %s font for messageFont\n",prop);
globalFont = serverFont;
}
if (XrmGetResource(rDB,
"Axiom.2D.buttonFont",
"Axiom.2D.Font",
str_type, &value) == True)
(void) strncpy(prop,value.addr,(int)value.size);
else
(void) strcpy(prop,buttonFontDefault);
if ((buttonFont = XLoadQueryFont(dsply, prop)) == NULL) {
fprintf(stderr,
"Warning: could not get the %s font for buttonFont\n",prop);
buttonFont = serverFont;
}
if (XrmGetResource(rDB,
"Axiom.2D.headerFont",
"Axiom.2D.Font",
str_type, &value) == True)
(void) strncpy(prop,value.addr,(int)value.size);
else
(void) strcpy(prop,headerFontDefault);
if ((headerFont = XLoadQueryFont(dsply, prop)) == NULL) {
fprintf(stderr,
"Warning: could not get the %s font for headerFont\n",prop);
headerFont = serverFont;
}
if (XrmGetResource(rDB,
"Axiom.2D.titleFont",
"Axiom.2D.Font",
str_type,&value) == True)
(void) strncpy(prop,value.addr,(int)value.size);
else
(void) strcpy(prop,titleFontDefault);
if ((titleFont = XLoadQueryFont(dsply, prop)) == NULL) {
fprintf(stderr,
"Warning: could not get the %s font for titleFont\n",prop);
titleFont = serverFont;
}
if (XrmGetResource(rDB,
"Axiom.2D.graphFont",
"Axiom.2D.Font",
str_type,&value) == True)
(void) strncpy(prop,value.addr,(int)value.size);
else
(void) strcpy(prop,graphFontDefault);
if ((graphFont = XLoadQueryFont(dsply, prop)) == NULL) {
fprintf(stderr,
"Warning: could not get the %s font for graphFont\n",prop);
graphFont = serverFont;
}
if (XrmGetResource(rDB,
"Axiom.2D.unitFont",
"Axiom.2D.Font",
str_type,&value) == True)
(void) strncpy(prop,value.addr,(int)value.size);
else
(void) strcpy(prop,unitFontDefault);
if ((unitFont = XLoadQueryFont(dsply, prop)) == NULL) {
fprintf(stderr,
"Warning: could not get the %s font for unitFont\n",prop);
unitFont = serverFont;
}
/**** Create widely used Graphic Contexts ****/
PSGlobalInit();
/* must initiate before using any G/PS functions
need character name: used as postscript GC variable
need to create ps GCs for all GCs used by drawings in viewWindow */
/* globalGC1 */
controlGCVals.foreground = monoColor(axesColorDefault);
controlGCVals.background = backgroundColor;
globalGC1 = XCreateGC(dsply,rtWindow,GCForeground | GCBackground ,
&controlGCVals);
carefullySetFont(globalGC1,globalFont);
/* create the equivalent GCs for ps */
PSCreateContext(globalGC1, "globalGC1", psNormalWidth, psButtCap,
psMiterJoin, psWhite, psBlack);
/* controlMessageGC */
controlGCVals.foreground = controlMessageColor;
controlMessageGC = XCreateGC(dsply,rtWindow,GCForeground | GCBackground
,&controlGCVals);
carefullySetFont(controlMessageGC,globalFont);
/* globalGC2 */
controlGCVals.foreground = monoColor(labelColor);
controlGCVals.background = backgroundColor;
globalGC2 = XCreateGC(dsply,rtWindow,GCForeground | GCBackground,
&controlGCVals);
carefullySetFont(globalGC2,buttonFont);
PSCreateContext(globalGC2, "globalGC2", psNormalWidth, psButtCap,
psMiterJoin, psWhite, psBlack);
/* trashGC */
trashGC = XCreateGC(dsply,rtWindow,0,&controlGCVals);
carefullySetFont(trashGC,buttonFont);
PSCreateContext(trashGC, "trashGC", psNormalWidth, psButtCap,
psMiterJoin, psWhite, psBlack);
/* globGC */
globGC = XCreateGC(dsply,rtWindow,0,&controlGCVals);
carefullySetFont(globGC,headerFont);
PSCreateContext(globGC, "globGC", psNormalWidth, psButtCap,
psMiterJoin, psWhite, psBlack);
/* anotherGC */
controlGCVals.line_width = colorWidth;
anotherGC = XCreateGC(dsply,rtWindow,GCBackground,&controlGCVals);
carefullySetFont(anotherGC,titleFont);
PSCreateContext(anotherGC, "anotherGC", psNormalWidth, psButtCap,
psMiterJoin, psWhite, psBlack);
/* processGC */
gcVals.background = backgroundColor;
processGC = XCreateGC(dsply,rtWindow,GCBackground ,&gcVals);
carefullySetFont(processGC,buttonFont);
/* graphGC */
graphGC = XCreateGC(dsply,rtWindow,GCBackground,&gcVals);
carefullySetFont(graphGC,graphFont);
PSCreateContext(graphGC, "graphGC", psNormalWidth, psButtCap,
psMiterJoin, psWhite, psBlack);
/* unitGC */
unitGC = XCreateGC(dsply,rtWindow,GCBackground ,&gcVals);
carefullySetFont(unitGC,unitFont);
PSCreateContext(unitGC, "unitGC", psNormalWidth, psButtCap,
psMiterJoin, psWhite, psBlack);
/**** Initialize Graph States ****/
for (i=0; i<maxGraphs; i++) {
graphStateArray[i].scaleX = 0.9;
graphStateArray[i].scaleY = 0.9;
graphStateArray[i].deltaX = 0.0;
graphStateArray[i].deltaY = 0.0;
graphStateArray[i].centerX = 0.0;
graphStateArray[i].centerY = 0.0;
graphStateArray[i].pointsOn = yes;
graphStateArray[i].connectOn = yes;
graphStateArray[i].splineOn = no;
graphStateArray[i].axesOn = yes;
graphStateArray[i].unitsOn = no;
graphStateArray[i].showing = no;
graphStateArray[i].selected = no;
graphStateBackupArray[i] = graphStateArray[i];
}
/**** Get Data from the Viewport Manager ****/
i = 123;
code=check(write(Socket,&i,intSize));
/* Check if I am getting stuff from FriCAS or, if I am viewAlone. */
readViewman(&viewAloned,intSize);
readViewman(&viewData,sizeof(view2DStruct));
readViewman(&i,intSize);
if (!(viewData.title = (char *)malloc(i))) {
fprintf(stderr,
"ERROR: Ran out of memory trying to receive the title.\n");
exitWithAck(RootWindow(dsply,scrn),Window,-1);
}
readViewman(viewData.title,i);
for (i=0; i<maxGraphs; i++) {
readViewman(&(graphArray[i].key),intSize);
if (graphArray[i].key) { /** this graph slot has data **/
getGraphFromViewman(i);
} /* if graph exists (graphArray[i].key is not zero) */
} /* for i in graphs */
viewport = makeView2D(&viewData);
control = viewport->controlPanel;
bsdSignal(SIGTERM,goodbye,DontRestartSystemCalls);
/* send acknowledgement to viewport manager */
i = 345;
check(write(Socket,&(viewport->viewWindow),sizeof(Window)));
processEvents();
goodbye(-1);
return(0); /* control never reaches here but compiler complains */
} /* main() */
