home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / oper_sys / emerald / emrldsys.lha / Kernel / X / XInterface.c
Encoding:
C/C++ Source or Header  |  1990-08-17  |  10.9 KB  |  455 lines
  1. #ifdef INCLUDE_X_WINDOWS
  2. #include "Kernel/h/system.h"
  3. #include "Kernel/h/macros.h"
  4. #include "Kernel/h/assert.h"
  5.  
  6. #include <sys/file.h>
  7. #include <sys/time.h>
  8. #include <errno.h>
  9.  
  10. #include "Kernel/h/stdTypes.h"
  11. #include "Kernel/h/ecTypes.h"
  12. #include "Kernel/h/emTypes.h"
  13. #include "Kernel/h/builtins.h"
  14. #include "Kernel/h/kmdTypes.h"
  15. #include "Kernel/h/emeraldTypes.h"
  16. #include "Kernel/h/kEvents.h"
  17. #include "Kernel/h/sigio.h"
  18. #undef True
  19. #include <X11/Xlib.h>
  20. #include <X11/Xutil.h>
  21.  
  22. static Display *display;
  23. static EmBitChunk *waitingEvent;
  24. static SSPtr   waitingProcess;
  25. extern SSPtr   preemptRunning();
  26. XWMHints xwmh={
  27.     (InputHint|StateHint),
  28.     False,
  29.     NormalState,
  30.     0,
  31.     0,
  32.     0,0,
  33.     0,
  34.     0
  35.   };
  36.  
  37. /* shumei -s */
  38. static  unsigned long black,white;
  39. /* shumei -e */
  40.  
  41. int XSIGIOOccurred(), XSockDead(), XEventHandler();
  42.  
  43. void *XCreateDisplay(es)
  44. EmString *es;
  45. {
  46.   char *s;
  47.  
  48.   s = malloc(es->sizeInBytes + 1);
  49.   (void) strncpy(s, es->data, es->sizeInBytes);
  50.   display = XOpenDisplay(s);
  51.   if (display == NULL) {
  52.     KMDTrace("X", 1, "Cannot initialize display\n");
  53.     return;
  54.   } 
  55.   if (fcntl(display->fd, F_SETFL, FASYNC ) < 0) {
  56.     perror("XCreateDisplay: first fcntl");
  57.   };
  58.   if (fcntl(display->fd, F_SETOWN, getpid()) < 0) {
  59.     perror("XCreateDisplay: second fcntl");
  60.   };
  61.  
  62.   SISetSockHandler(display->fd, SIREAD, (SIHandlerPtr) XSIGIOOccurred);
  63.   SISetSockHandler(display->fd, SIEXCEPT, (SIHandlerPtr) XSockDead);
  64.   SIEnsureSIGIO();
  65.  
  66.   black = BlackPixel(display,DefaultScreen(display));
  67.   white = WhitePixel(display,DefaultScreen(display));
  68. }
  69.  
  70. int XSIGIOOccurred(fKind, fSock)
  71. int     fKind, fSock;
  72. {
  73.   SIRemoveSockHandler(fSock, SIREAD);
  74.   HoldSigs();
  75.   QueueTask(XEventHandler, (char *) fSock);
  76.   ReleaseSigs();
  77.   return 0; /* procedure ought to be void */
  78. }
  79.  
  80.  
  81. /**********************************************************************/
  82. int XSockDead(fSock)
  83. int             fSock;
  84. {
  85.     KMDTrace("X", 3, "Socket #%d died.\n", fSock);
  86.     display = NULL;
  87. }
  88.  
  89. /**********************************************************************/
  90. /*      XEventHandler
  91. /**********************************************************************/
  92. int XEventHandler(fSock)
  93. int              fSock;
  94. /* The socket has become available for input, read the event */
  95. {
  96.     SSPtr                           theProcess;
  97.  
  98.     KMDTrace("X", 3, "Events on socket %d\n", fSock);
  99.  
  100.     /* Attempt to read */
  101.     if (XPending(display) <= 0) {
  102.       /* Must have been XError events */
  103.       KMDTrace("X", 5, "XNextEvent found no events\n");
  104.       SISetSockHandler(display->fd, SIREAD, (SIHandlerPtr) XSIGIOOccurred);
  105.       return;
  106.     }
  107.     XNextEvent(display, (XEvent *)waitingEvent->data);
  108.     KMDTrace("X", 5, "XNextEvent returned\n");
  109.     KMDTrace("X", 5, "event = (%d %d %d %d %d)\n", 
  110.       *(0 + (int *)waitingEvent->data),
  111.       *(1 + (int *)waitingEvent->data),
  112.       *(2 + (int *)waitingEvent->data),
  113.       *(3 + (int *)waitingEvent->data),
  114.       *(4 + (int *)waitingEvent->data));
  115.     theProcess                  = waitingProcess;
  116.     theProcess->resultBrand     = DataBrand;
  117.     theProcess->regs.arg1       = 1;
  118.     waitingProcess              = (SSPtr) NULL;
  119.     waitingEvent                = NULL;
  120.     schedule(theProcess);
  121. }
  122.  
  123. /**********************************************************************/
  124. /*      EMXReadEvent                                                    */
  125. /**********************************************************************/
  126.  
  127. /*Kernel Call */
  128. void EMXReadEvent(fEvent)
  129. GODP            fEvent;
  130. {
  131.   int                             sock, i, count, length;
  132.   EmBitChunk                     *event;
  133.   SSPtr                           theProcess;
  134.   AbConPtr                        eventAbCon, OIDOIDOIDToAbCon();
  135.   
  136.   theProcess = preemptRunning();
  137.  
  138.   KMDTrace("X", 4, "EMXReadEvent in %s\n", PPSSPlace(theProcess));
  139.  
  140.   if (fEvent == (GODP) EMNIL) {
  141.     KMDTrace("X", 2, "Event is NIL in EMXReadEvent.\n");
  142.     fail(theProcess);
  143.     return;
  144.   }
  145.  
  146.   if (!fEvent->tag.isResident) {
  147.     KMDTrace("X", 2, "Event is non-resident.\n");
  148.     eventAbCon = OIDOIDOIDToAbCon(
  149.       fEvent->dataPtr->myCodePtr->ownAbstractType,
  150.       OIDOfBuiltin(B_INSTAT, ANYINDEX),
  151.       fEvent->dataPtr->myCodePtr->ownOID);
  152.     unavail(theProcess, fEvent, eventAbCon);
  153.     return;
  154.   }
  155.  
  156.   if (fEvent->tag.global) {
  157.     event = (EmBitChunk *) fEvent->dataPtr;
  158.   } else event = (EmBitChunk *) fEvent;
  159.  
  160.   /* Check for other readers */
  161.   if (NonNULL(waitingProcess)) {
  162.     KMDTrace("X", 2, "Read socket busy.\n");
  163.     fail(theProcess);
  164.     return;
  165.   }
  166.   
  167.   /* Check the size of the bitchunk */
  168.   if (event->sizeInBytes < sizeof(XEvent)) {
  169.     KMDTrace("X", 2, "Read attempt with too small BitChunk %d should be %d.\n",
  170.       event->sizeInBytes, sizeof(XEvent));
  171.     fail(theProcess);
  172.     return;
  173.   }
  174.     
  175.   /* Check for a display */
  176.   if (!display) {
  177.     KMDTrace("X", 1, "Read attempt with no display (= nil).\n");
  178.     fail(theProcess);
  179.     return;
  180.   }
  181.  
  182.   /* Attempt to read */
  183.   if (XPending(display) <= 0) {
  184.     KMDTrace("X", 3, "EMXReadEvent blocking %s at %s\n",
  185.       PPPOID(theProcess->processOID), PPSSPlace(theProcess));
  186.     waitingEvent         = event;
  187.     waitingProcess       = theProcess;
  188.     theProcess->status.rs   = SSReadIOWait;
  189.     KMDTrace("LineNumber", 3, "%s blocking on X read in %s\n",
  190.       PPPOID(theProcess->processOID), PPSSPlace(theProcess));
  191.     SISetSockHandler(display->fd, SIREAD, (SIHandlerPtr) XSIGIOOccurred);
  192.     return;
  193.   }
  194.   XNextEvent(display, (XEvent *)event->data);
  195.   theProcess->resultBrand = DataBrand;
  196.   theProcess->regs.arg1 = 0;
  197.   schedule(theProcess);
  198. }
  199.  
  200. /* Change from here on */
  201.  
  202. int EMXCreateWindow(pos, size, name)
  203. int pos, size;
  204. EmString *name;
  205. {
  206.   Window window;
  207.   XSizeHints xsh; 
  208.   char *myname;
  209.   myname = calloc(1, name->sizeInBytes+1);
  210.   strncpy(myname, name->data, name->sizeInBytes);
  211.  
  212.   if (display == NULL) {
  213.     KMDTrace("X", 1, "Create window called with no display\n");
  214.     return(-1);
  215.   }
  216.   xsh.x = pos >> 16;
  217.   xsh.y = pos & 0xffff;
  218.   xsh.width = size >> 16;
  219.   xsh.height = size & 0xffff;
  220.   xsh.flags = (USPosition|USSize); 
  221.  
  222.   KMDTrace("X", 3, "Create window at (%d, %d) size (%d, %d)\n",
  223.     xsh.x, xsh.y, xsh.width, xsh.height);
  224.   window = XCreateSimpleWindow(display, DefaultRootWindow(display), xsh.x, xsh.y, xsh.width, xsh.height, 1,black,white); 
  225.   KMDTrace("X", 3, "XCreateWindow returns %d\n", window);
  226. /* norm, i am not sure the parameter: None should be argv, 0 should be argc 
  227.    but it works for right now */
  228.   XSetStandardProperties(display,window,myname,myname,None,NULL,0,&xsh);
  229. /*
  230.   XSetWHints(display,window,&xwhm);
  231. */
  232.   XMapWindow(display,window);
  233.   return(window);
  234. }
  235.  
  236.  
  237. /*-----------------------------------------------------------------------
  238.  * FUCTION : EMXSelectInput
  239.  *           To requests X server report the events associated with the event
  240.  *           Mask
  241.  * Jyhlin Chang Jul 15,1988
  242.  *-----------------------------------------------------------------------*/
  243.  
  244. void EMXSelectInput(w, event_mask)
  245.   Window w;
  246.   unsigned long event_mask;
  247. {
  248.   XSelectInput(display, w, event_mask);
  249.  
  250. }/*EMXSelectInput*/
  251.  
  252.  
  253.  
  254. GC EMXInitGc(win)
  255. Window win;
  256. {
  257.   XGCValues gcvalues;
  258.   GC gc;
  259.   char *font;
  260.   XFontStruct *fontstruct;
  261.  
  262.   gcvalues.foreground = black; 
  263.   gcvalues.background = white; 
  264.   gcvalues.line_width =  0;
  265.   font = "9x15";
  266.   if ((fontstruct = XLoadQueryFont(display , font)) == NULL) {
  267.     fprintf(stderr, "%s: display %s doesn't know font %s\n",
  268.         "ha,wrong", DisplayString(display), font);
  269.     exit(1);
  270.     }
  271.   gcvalues.font = fontstruct->fid;
  272.   gc = XCreateGC(display,win,(GCLineWidth|GCFont|GCForeground|GCBackground),
  273.        &gcvalues);
  274.   return (gc);
  275. }
  276.  
  277. EMXSetWidth(gc, win,width )
  278. GC gc;
  279. Window  win;
  280. int width;
  281. {
  282.   XGCValues gcvalues;
  283.  
  284.   gcvalues.line_width =  width;
  285.   XChangeGC(display,gc,GCLineWidth,&gcvalues);
  286. } 
  287.  
  288. EMXSetFont(gc,win,font)
  289. GC gc;
  290. Window win;
  291. EmString  *font; 
  292. {
  293.   XGCValues gcv;
  294.   XFontStruct *fontstruct;
  295.   char *blotto = calloc(1, font->sizeInBytes + 1);
  296.   strncpy(blotto, font->data, font->sizeInBytes); 
  297.     if ((fontstruct = XLoadQueryFont(display , blotto)) == NULL) {
  298.     fprintf(stderr, "%s: display %s doesn't know font %s\n",
  299.         "ha,wrong", DisplayString(display), blotto);
  300.     exit(1);
  301.     }
  302.     gcv.font = fontstruct->fid;
  303. /*
  304.     gcv.foreground = black;
  305.     gcv.background = white;
  306.     gc = XCreateGC(display,win,(GCFont|GCForeground|GCBackground), &gcv);
  307. */
  308.     XChangeGC(display,gc,GCFont, &gcv);
  309. }
  310.  
  311. void EMXLine(win, p1, p2,gc)
  312. Window win;
  313. int  p1, p2;
  314. GC gc;
  315. {
  316.   int x1, y1, x2, y2;
  317.   x1 = p1 >> 16;
  318.   y1 = p1 & 0xffff;
  319.   x2 = p2 >> 16;
  320.   y2 = p2 & 0xffff;
  321.   KMDTrace("X", 3, "X Line on window %d from (%d, %d) to (%d, %d)\n",
  322.     win, x1, y1, x2, y2);
  323.   XDrawLine(display,win,gc,x1, y1, x2, y2);
  324.   KMDTrace("X", 3, "XLine done\n");
  325. }
  326.  
  327. void EMXString(win, string, x, y, gc )
  328. Window win;
  329. EmString *string; 
  330. int x,y;
  331. GC gc;
  332. {
  333.     KMDTrace("X", 3, "XString begin %s\n",string);
  334.     XDrawString(display, win, gc, x, y, string->data, string->sizeInBytes);
  335.     XFlush(display);
  336.     KMDTrace("X", 3, "XString done\n");
  337. }
  338. void EMXConfigureWindow(win, p, s)
  339. int win, p, s;
  340. {
  341.   int x, y, w, h;
  342.   x = p >> 16;
  343.   y = p & 0xffff;
  344.   w = s >> 16;
  345.   h = s & 0xffff;
  346.   KMDTrace("X", 3, "X ConfigureWindow on window %d (%d, %d) (%d, %d)\n",
  347.     win, x, y, w, h);
  348.   XConfigureWindow(win, x, y, w, h);
  349.   KMDTrace("X", 3, "XConfigureWindow done\n");
  350. }
  351.  
  352. void EMXFlush()
  353. {
  354.   KMDTrace("X", 3, "X Flush called\n");
  355.   XFlush(display);
  356.   KMDTrace("X", 3, "X Flush done\n");
  357. }
  358.  
  359. int sync_write(fd, b, l)
  360. int fd, l;
  361. char *b;
  362. {
  363.   int write_stat, nTimes = 0;
  364.   while ((write_stat = write(fd, b, l)) < 0 && errno == EWOULDBLOCK) {
  365.     nTimes ++;
  366.     /* wait a while */
  367.   }
  368.   if (nTimes > 0) KMDTrace("X", 1, "Sync_write had to wait %d times\n");
  369.   return(write_stat);
  370. }
  371.  
  372. int sync_writev(fd, iov, l)
  373. int fd, l;
  374. struct iovec *iov;
  375. {
  376.   int write_stat, nTimes = 0;
  377.   while ((write_stat = write(fd, iov, l)) < 0 && errno == EWOULDBLOCK) {
  378.     nTimes ++;
  379.     /* wait a while */
  380.   }
  381.   if (nTimes > 0) KMDTrace("X", 1, "Sync_writev had to wait %d times\n");
  382.   return(write_stat);
  383. }
  384.  
  385. EMXRaiseWindow(w) 
  386. Window w;
  387. {
  388.   XRaiseWindow(display,w);
  389. }
  390.  
  391.  
  392. EMXLowerWindow(w)
  393. Window w;
  394. {
  395.   XLowerWindow(display,w);
  396. }
  397.  
  398.  
  399. EMXUnmapWindow(w)
  400. Window w;
  401. {
  402.   XUnmapWindow(display,w);
  403. }
  404.  
  405. EMXResizeWindow(w,x,y)
  406. Window w;
  407. int x,y;
  408. {
  409.   XResizeWindow(display,w,x,y);
  410. }
  411.  
  412. EMXMoveWindow(w,x,y)
  413. Window w;
  414. int x,y;
  415. {
  416.   XMoveWindow(display,w,x,y);
  417. }
  418.  
  419. EMXCloseWindow(w)
  420. Window w;
  421. {
  422.   XDestroyWindow(display,w);
  423. }
  424.  
  425. void XInit()
  426. {
  427.   EmString es;
  428.   DebugMsg(1, "XInit\n");
  429.   es.sizeInBytes = 0;
  430.   XCreateDisplay(&es);
  431.   KMDSetTrace(X);
  432.   KMDSetProcedure(EMXInitGc);
  433.   KMDSetProcedure(EMXSetFont);
  434.   KMDSetProcedure(EMXSetWidth);
  435.   KMDSetProcedure(EMXLine);
  436.   KMDSetProcedure(EMXString);
  437.   KMDSetProcedure(EMXCreateWindow);
  438.   KMDSetProcedure(EMXUnmapWindow);
  439.   KMDSetProcedure(EMXCloseWindow);
  440.   KMDSetProcedure(EMXMoveWindow);
  441.   KMDSetProcedure(EMXResizeWindow);
  442.   KMDSetProcedure(EMXConfigureWindow);
  443.   KMDSetProcedure(EMXRaiseWindow);
  444.   KMDSetProcedure(EMXLowerWindow);
  445.   KMDSetProcedure(EMXFlush);
  446.   KMDSetProcedure(EMXReadEvent);
  447.  
  448.   KMDSetProcedure(EMXSelectInput);
  449. }
  450.  
  451. #else
  452. void XInit()
  453. {}
  454. #endif
  455.