home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / x / volume14 / ultrix.patch / part02 < prev    next >
Text File  |  1991-08-26  |  63KB  |  2,199 lines
  1. Path: uunet!cs.utexas.edu!sun-barr!cronkite.Central.Sun.COM!exodus!crl.dec.com!treese
  2. From: treese@crl.dec.com
  3. Newsgroups: comp.sources.x
  4. Subject: v14i015: ddx support for ULTRIX 4.2 and X11R4, Part02/02
  5. Message-ID: <19079@exodus.Eng.Sun.COM>
  6. Date: 27 Aug 91 06:09:06 GMT
  7. References: <csx-14i014-ultrix.patch@uunet.UU.NET>
  8. Sender: news@exodus.Eng.Sun.COM
  9. Lines: 2187
  10. Approved: argv@sun.com
  11.  
  12. Submitted-by: treese@crl.dec.com
  13. Posting-number: Volume 14, Issue 15
  14. Archive-name: ultrix.patch/part02
  15.  
  16. #! /bin/sh
  17. # This is a shell archive.  Remove anything before this line, then unpack
  18. # it by saving it into a file and typing "sh file".  To overwrite existing
  19. # files, type "sh file -c".  You can also feed this as standard input via
  20. # unshar, or by typing "sh <file", e.g..  If this archive is complete, you
  21. # will see the following message at the end:
  22. #        "End of archive 2 (of 2)."
  23. # Contents:  server/ddx/dec/ws/init.c server/ddx/dec/ws/keynames.h
  24. #   server/ddx/dec/ws/patchlevel.h server/ddx/dec/ws/ws.h
  25. #   server/ddx/dec/ws/ws_color.c server/ddx/dec/ws/ws_io.c
  26. # Wrapped by treese@wachusett.crl.dec.com on Wed Jul 24 23:27:14 1991
  27. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  28. if test -f 'server/ddx/dec/ws/init.c' -a "${1}" != "-c" ; then 
  29.   echo shar: Will not clobber existing file \"'server/ddx/dec/ws/init.c'\"
  30. else
  31. echo shar: Extracting \"'server/ddx/dec/ws/init.c'\" \(7097 characters\)
  32. sed "s/^X//" >'server/ddx/dec/ws/init.c' <<'END_OF_FILE'
  33. X/***********************************************************
  34. Copyright 1991 by Digital Equipment Corporation, Maynard, Massachusetts,
  35. and the Massachusetts Institute of Technology, Cambridge, Massachusetts.
  36. X
  37. X                        All Rights Reserved
  38. X
  39. Permission to use, copy, modify, and distribute this software and its 
  40. documentation for any purpose and without fee is hereby granted, 
  41. provided that the above copyright notice appear in all copies and that
  42. both that copyright notice and this permission notice appear in 
  43. supporting documentation, and that the names of Digital or MIT not be
  44. used in advertising or publicity pertaining to distribution of the
  45. software without specific, written prior permission.  
  46. X
  47. DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  48. ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  49. DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  50. ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  51. WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  52. ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  53. SOFTWARE.
  54. X
  55. X******************************************************************/
  56. X
  57. X/* $Header: init.c,v 1.1 91/05/11 10:51:07 rws Exp $ */
  58. X
  59. X#include <stdio.h>
  60. X#include <sys/types.h>
  61. X#include <sys/file.h>
  62. X#include <sys/time.h>
  63. X#include <sys/tty.h>
  64. X#include <errno.h>
  65. X#include <sys/devio.h>
  66. X
  67. X#include "X.h"
  68. X
  69. X#include "scrnintstr.h"
  70. X#include "servermd.h"
  71. X
  72. X#include "input.h"
  73. X/* XXX */
  74. X#include <sys/workstation.h>
  75. X#include <sys/inputdevice.h>
  76. X#include "ws.h"
  77. X
  78. extern void wsMouseProc();
  79. extern void wsKeybdProc();
  80. extern void wsClick();
  81. extern void wsChangePointerControl();
  82. extern KeybdCtrl defaultKeyboardControl;
  83. ws_event_queue    *queue;
  84. X
  85. X#define NUMFORMATS 3
  86. static    PixmapFormatRec formats[] = {
  87. X    {1, 1, BITMAP_SCANLINE_PAD},     /* 1 bit deep */
  88. X    {8, 8, BITMAP_SCANLINE_PAD},     /* 8-bit deep */
  89. X    {24, 32, BITMAP_SCANLINE_PAD},
  90. X};
  91. X
  92. Bool fbInitProc();
  93. extern int num_accelerator_types;
  94. X
  95. extern wsAcceleratorTypes types[];
  96. X
  97. ws_screen_descriptor screenDesc[MAXSCREENS];
  98. X
  99. Bool
  100. commandLineMatch( argc, argv, pat, pmatch)
  101. X    int         argc;           /* may NOT be changed */
  102. X    char *      argv[];         /* may NOT be changed */
  103. X    char *      pat;
  104. X{
  105. X    int         ic;
  106. X
  107. X    for ( ic=0; ic<argc; ic++)
  108. X        if ( strcmp( argv[ic], pat) == 0)
  109. X            return TRUE;
  110. X    return FALSE;
  111. X}
  112. X
  113. Bool
  114. commandLinePairMatch( argc, argv, pat, pmatch)
  115. X    int         argc;           /* may NOT be changed */
  116. X    char *      argv[];         /* may NOT be changed */
  117. X    char *      pat;
  118. X    char **     pmatch;         /* RETURN */
  119. X{
  120. X    register int         ic;
  121. X
  122. X    for ( ic=0; ic<argc; ic++)
  123. X        if ( strcmp( argv[ic], pat) == 0) {
  124. X            *pmatch = argv[ ic+1];
  125. X            return TRUE;
  126. X    }
  127. X    return FALSE;
  128. X}
  129. X
  130. ws_descriptor wsinfo;
  131. int wsFd;
  132. int ws_cpu;
  133. X
  134. int wsScreenPrivateIndex;
  135. X/* the following filth is forced by a broken dix interface */
  136. X
  137. InitOutput(screenInfo, argc, argv)
  138. X    ScreenInfo *screenInfo;
  139. X    int argc;
  140. X    char **argv;
  141. X{
  142. X    int i;
  143. X    int si = 0;
  144. X    static int inited = FALSE;
  145. X    static int ma = 4;
  146. X    static int mt = 4;
  147. X    static PtrCtrl ctrl;
  148. X    static int  clicklevel;
  149. X
  150. X    screenInfo->imageByteOrder = IMAGE_BYTE_ORDER;
  151. X    screenInfo->bitmapScanlineUnit = BITMAP_SCANLINE_UNIT;
  152. X    screenInfo->bitmapScanlinePad = BITMAP_SCANLINE_PAD;
  153. X    screenInfo->bitmapBitOrder = BITMAP_BIT_ORDER;
  154. X    screenInfo->numPixmapFormats = NUMFORMATS;
  155. X
  156. X    for (i=0; i< NUMFORMATS; i++) {
  157. X    screenInfo->formats[i].depth = formats[i].depth;
  158. X    screenInfo->formats[i].bitsPerPixel = formats[i].bitsPerPixel;
  159. X    screenInfo->formats[i].scanlinePad = formats[i].scanlinePad;
  160. X    }
  161. X
  162. X    if (!inited) {
  163. X    char *clickvolume;
  164. X    char *mouseAcceleration;
  165. X    char *mouseThreshold;
  166. X    ws_keyboard_control control;
  167. X        inited = TRUE;
  168. X        if ((wsFd = open("/dev/mouse",  O_RDWR, 0)) < 0) {
  169. X        ErrorF("couldn't open device\n");
  170. X        exit (1);
  171. X    }
  172. X    if (ioctl (wsFd, GET_WORKSTATION_INFO, &wsinfo) != 0) {
  173. X        ErrorF("GET_WORKSTATION_INFO failed \n");
  174. X        exit(1);
  175. X    }
  176. X    control.device_number = wsinfo.console_keyboard;
  177. X    if (ioctl(wsFd, GET_KEYBOARD_CONTROL, &control) == -1) {
  178. X        ErrorF("GET_KEYBOARD_CONTROL failed\n");
  179. X        exit(1);
  180. X    }
  181. X    defaultKeyboardControl.click = control.click;
  182. X    defaultKeyboardControl.bell = control.bell;
  183. X    defaultKeyboardControl.bell_pitch = control.bell_pitch;
  184. X    defaultKeyboardControl.bell_duration = control.bell_duration;
  185. X    defaultKeyboardControl.autoRepeat = control.auto_repeat;
  186. X    defaultKeyboardControl.leds = control.leds;
  187. X    bcopy (control.autorepeats, defaultKeyboardControl.autoRepeats, 32);
  188. X    
  189. X    /* turn off cursors on additional screens initially */
  190. X/* 
  191. X * jmg - have to do a lot of other stuff here dealing with visuals
  192. X *  and depths 
  193. X */
  194. X       /*
  195. X    * deal with arguments.  Note we don't bother until we've successfully
  196. X    * opened the device.
  197. X    */
  198. X
  199. X    if (commandLinePairMatch( argc, argv, "c", &clickvolume))
  200. X        sscanf( clickvolume, "%d", &clicklevel);
  201. X    if (commandLinePairMatch( argc, argv, "-a", &mouseAcceleration))
  202. X        sscanf( mouseAcceleration, "%d", &ma);
  203. X    if (commandLinePairMatch( argc, argv, "-t", &mouseThreshold))
  204. X        sscanf( mouseThreshold, "%d", &mt);
  205. X
  206. X    }
  207. X    ctrl.num = ma;
  208. X    ctrl.den = 1;
  209. X    ctrl.threshold = mt;
  210. X    wsChangePointerControl( (DevicePtr) NULL, &ctrl);
  211. X    wsClick(clicklevel);
  212. X    if (commandLineMatch(argc, argv, "-c")) wsClick(0);
  213. X    wsScreenPrivateIndex = AllocateScreenPrivateIndex();
  214. X    ws_cpu = wsinfo.cpu;
  215. X    for(i = 0; i < wsinfo.num_screens_exist; i++) {
  216. X    int j, DECaccelerator = FALSE;
  217. X    screenDesc[si].screen = i;
  218. X    if (ioctl(wsFd,     GET_SCREEN_INFO, &screenDesc[si]) == -1) {
  219. X        ErrorF("GET_SCREEN_INFO failed\n");
  220. X        exit(1);
  221. X    }
  222. X    if (si >= MAXSCREENS) {
  223. X        ErrorF ("Server configured for %d screens, can't configure screen %d\n", MAXSCREENS, si);
  224. X        break;
  225. X    }
  226. X    for (j = 0; j < num_accelerator_types; j++) {
  227. X        if (strcmp (screenDesc[si].moduleID, types[j].moduleID) == 0) {
  228. X        DECaccelerator = TRUE;
  229. X        break;
  230. X        }
  231. X    }
  232. X        if(DECaccelerator)
  233. X        j = AddScreen(types[j].createProc, argc, argv);
  234. X    else
  235. X        j = AddScreen(fbInitProc, argc, argv);
  236. X    /*
  237. X     * AddScreen either returns -1 (error) or # of screens installed
  238. X     * (current index).  screenDesc[] is exactly parallel to
  239. X     * screenInfo.screens[] since the initProc() arg will be called
  240. X     * with AddScreen's index, which in turn gets used for screenDesc[].
  241. X     */
  242. X    if (j == -1) {
  243. X        ErrorF("Could not AddScreen, ID = %s\n",
  244. X            screenDesc[si].moduleID);
  245. X    } else
  246. X        si = j+1;
  247. X    }
  248. X#ifdef XINPUT
  249. X    ExtInitOutput(screenInfo, argc, argv);
  250. X#endif
  251. X}
  252. X
  253. X
  254. X
  255. void
  256. InitInput(argc, argv)
  257. X    int argc;
  258. X    char *argv[];
  259. X{
  260. X    DevicePtr p, k;
  261. X    static int inited = FALSE;
  262. X    
  263. X    p = AddInputDevice(wsMouseProc, TRUE);
  264. X
  265. X    k = AddInputDevice(wsKeybdProc, TRUE);
  266. X
  267. X    RegisterPointerDevice(p);
  268. X    RegisterKeyboardDevice(k);
  269. X
  270. X#ifdef XINPUT
  271. X    ExtInitInput(argc, argv);
  272. X#endif
  273. X
  274. X    if (!inited) {
  275. X    inited = TRUE;
  276. X    if (ioctl(wsFd,  GET_AND_MAP_EVENT_QUEUE, &queue) == -1)  {
  277. X        ErrorF("GET_AND_MAP_EVENT_QUEUE failed\n");
  278. X        exit(1);
  279. X    }
  280. X    }
  281. X
  282. X}
  283. END_OF_FILE
  284. if test 7097 -ne `wc -c <'server/ddx/dec/ws/init.c'`; then
  285.     echo shar: \"'server/ddx/dec/ws/init.c'\" unpacked with wrong size!
  286. fi
  287. # end of 'server/ddx/dec/ws/init.c'
  288. fi
  289. if test -f 'server/ddx/dec/ws/keynames.h' -a "${1}" != "-c" ; then 
  290.   echo shar: Will not clobber existing file \"'server/ddx/dec/ws/keynames.h'\"
  291. else
  292. echo shar: Extracting \"'server/ddx/dec/ws/keynames.h'\" \(4272 characters\)
  293. sed "s/^X//" >'server/ddx/dec/ws/keynames.h' <<'END_OF_FILE'
  294. X/***********************************************************
  295. Copyright 1991 by Digital Equipment Corporation, Maynard, Massachusetts,
  296. and the Massachusetts Institute of Technology, Cambridge, Massachusetts.
  297. X
  298. X                        All Rights Reserved
  299. X
  300. Permission to use, copy, modify, and distribute this software and its 
  301. documentation for any purpose and without fee is hereby granted, 
  302. provided that the above copyright notice appear in all copies and that
  303. both that copyright notice and this permission notice appear in 
  304. supporting documentation, and that the names of Digital or MIT not be
  305. used in advertising or publicity pertaining to distribution of the
  306. software without specific, written prior permission.  
  307. X
  308. DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  309. ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  310. DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  311. ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  312. WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  313. ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  314. SOFTWARE.
  315. X
  316. X******************************************************************/
  317. X/* Keycodes for lk201 and lk401 keyboards used by code in ws_io.c 
  318. X    that loads default keysym values from a file.
  319. X*/
  320. X
  321. X#define MIN_LK201_KEY            86
  322. X#define MAX_LK201_KEY           251
  323. X#define LK201_GLYPHS_PER_KEY      2
  324. X
  325. X/* the keys themselves */
  326. X
  327. X#define KEY_F1             86
  328. X#define KEY_F2             87
  329. X#define KEY_F3             88
  330. X#define KEY_F4             89
  331. X#define KEY_F5             90
  332. X#define KEY_F6            100
  333. X#define KEY_F7            101
  334. X#define KEY_F8            102
  335. X#define KEY_F9            103
  336. X#define KEY_F10            104
  337. X#define KEY_F11            113
  338. X#define KEY_F12            114
  339. X#define KEY_F13            115
  340. X#define KEY_F14            116
  341. X#define KEY_HELP        124
  342. X#define KEY_MENU        125
  343. X#define KEY_F17            128
  344. X#define KEY_F18            129
  345. X#define KEY_F19            130
  346. X#define KEY_F20            131
  347. X#define KEY_FIND        138
  348. X#define KEY_INSERT_HERE        139
  349. X#define KEY_REMOVE        140
  350. X#define KEY_SELECT        141
  351. X#define KEY_PREV_SCREEN        142
  352. X#define KEY_NEXT_SCREEN        143
  353. X#define KEY_KP_0        146    /* key pad */
  354. X#define KEY_KP_PERIOD        148    /* key pad */
  355. X#define KEY_KP_ENTER        149    /* key pad */
  356. X#define KEY_KP_1        150    /* key pad */
  357. X#define KEY_KP_2        151    /* key pad */
  358. X#define KEY_KP_3        152    /* key pad */
  359. X#define KEY_KP_4        153    /* key pad */
  360. X#define KEY_KP_5        154    /* key pad */
  361. X#define KEY_KP_6        155    /* key pad */
  362. X#define KEY_KP_COMMA        156    /* key pad */
  363. X#define KEY_KP_7        157    /* key pad */
  364. X#define KEY_KP_8        158    /* key pad */
  365. X#define KEY_KP_9        159    /* key pad */
  366. X#define KEY_KP_HYPHEN        160
  367. X#define KEY_KP_PF1        161
  368. X#define KEY_KP_PF2        162
  369. X#define KEY_KP_PF3        163
  370. X#define KEY_KP_PF4        164
  371. X#define KEY_LEFT        167
  372. X#define KEY_RIGHT        168
  373. X#define KEY_DOWN        169
  374. X#define KEY_UP            170
  375. X#define KEY_SHIFT_R        171    /* LK401 */
  376. X#define KEY_ALT_L        172    /* LK401 */
  377. X#define KEY_COMPOSE_R        173    /* LK401 */
  378. X#define KEY_SHIFT        174
  379. X#define KEY_SHIFT_L        174
  380. X#define KEY_CTRL        175
  381. X#define KEY_LOCK        176
  382. X#define KEY_COMPOSE        177
  383. X#define KEY_APPLE        177
  384. X#define KEY_META        177
  385. X#define KEY_ALT_R        178    /* LK401 */
  386. X#define KEY_DELETE        188
  387. X#define KEY_RETURN        189
  388. X#define KEY_TAB            190
  389. X#define KEY_TILDE        191
  390. X#define KEY_TR_1        192    /* Top Row */
  391. X#define KEY_Q            193
  392. X#define KEY_A            194
  393. X#define KEY_Z            195
  394. X#define KEY_TR_2        197
  395. X#define KEY_W            198
  396. X#define KEY_S            199
  397. X#define KEY_X            200
  398. X#define KEY_LANGLE_RANGLE    201    /* xxx */
  399. X#define KEY_TR_3        203
  400. X#define KEY_E            204
  401. X#define KEY_D            205
  402. X#define KEY_C            206
  403. X#define KEY_TR_4        208
  404. X#define KEY_R            209
  405. X#define KEY_F            210
  406. X#define KEY_V            211
  407. X#define KEY_SPACE        212
  408. X#define KEY_TR_5        214
  409. X#define KEY_T            215
  410. X#define KEY_G            216
  411. X#define KEY_B            217
  412. X#define KEY_TR_6        219
  413. X#define KEY_Y            220
  414. X#define KEY_H            221
  415. X#define KEY_N            222
  416. X#define KEY_TR_7        224
  417. X#define KEY_U            225
  418. X#define KEY_J            226
  419. X#define KEY_M            227
  420. X#define KEY_TR_8        229
  421. X#define KEY_I            230
  422. X#define KEY_K            231
  423. X#define KEY_COMMA        232    /* xxx */
  424. X#define KEY_TR_9        234
  425. X#define KEY_O            235
  426. X#define KEY_L            236
  427. X#define KEY_PERIOD        237    /* xxx */
  428. X#define KEY_TR_0        239
  429. X#define KEY_P            240
  430. X#define KEY_SEMICOLON        242    /* xxx */
  431. X#define KEY_QMARK        243
  432. X#define KEY_PLUS        245    /* xxx */
  433. X#define KEY_RBRACE        246
  434. X#define KEY_VBAR        247    /* xxx */
  435. X#define KEY_UBAR        249    /* xxx */
  436. X#define KEY_LBRACE        250
  437. X#define KEY_QUOTE        251
  438. END_OF_FILE
  439. if test 4272 -ne `wc -c <'server/ddx/dec/ws/keynames.h'`; then
  440.     echo shar: \"'server/ddx/dec/ws/keynames.h'\" unpacked with wrong size!
  441. fi
  442. # end of 'server/ddx/dec/ws/keynames.h'
  443. fi
  444. if test -f 'server/ddx/dec/ws/patchlevel.h' -a "${1}" != "-c" ; then 
  445.   echo shar: Will not clobber existing file \"'server/ddx/dec/ws/patchlevel.h'\"
  446. else
  447. echo shar: Extracting \"'server/ddx/dec/ws/patchlevel.h'\" \(21 characters\)
  448. sed "s/^X//" >'server/ddx/dec/ws/patchlevel.h' <<'END_OF_FILE'
  449. X#define PATCHLEVEL 0
  450. END_OF_FILE
  451. if test 21 -ne `wc -c <'server/ddx/dec/ws/patchlevel.h'`; then
  452.     echo shar: \"'server/ddx/dec/ws/patchlevel.h'\" unpacked with wrong size!
  453. fi
  454. # end of 'server/ddx/dec/ws/patchlevel.h'
  455. fi
  456. if test -f 'server/ddx/dec/ws/ws.h' -a "${1}" != "-c" ; then 
  457.   echo shar: Will not clobber existing file \"'server/ddx/dec/ws/ws.h'\"
  458. else
  459. echo shar: Extracting \"'server/ddx/dec/ws/ws.h'\" \(3160 characters\)
  460. sed "s/^X//" >'server/ddx/dec/ws/ws.h' <<'END_OF_FILE'
  461. X/***********************************************************
  462. Copyright 1991 by Digital Equipment Corporation, Maynard, Massachusetts,
  463. and the Massachusetts Institute of Technology, Cambridge, Massachusetts.
  464. X
  465. X                        All Rights Reserved
  466. X
  467. Permission to use, copy, modify, and distribute this software and its 
  468. documentation for any purpose and without fee is hereby granted, 
  469. provided that the above copyright notice appear in all copies and that
  470. both that copyright notice and this permission notice appear in 
  471. supporting documentation, and that the names of Digital or MIT not be
  472. used in advertising or publicity pertaining to distribution of the
  473. software without specific, written prior permission.  
  474. X
  475. DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  476. ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  477. DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  478. ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  479. WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  480. ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  481. SOFTWARE.
  482. X
  483. X******************************************************************/
  484. X/* $Header: ws.h,v 1.1 91/05/11 10:51:12 rws Exp $ */
  485. X
  486. X/* $Log:    ws.h,v $
  487. X * Revision 1.1  91/05/11  10:51:12  rws
  488. X * Initial revision
  489. X * 
  490. X * Revision 1.5  90/07/25  17:35:19  gringort
  491. X * added new field for monitor type arg
  492. X * 
  493. X * Revision 1.4  90/07/16  17:45:16  gringort
  494. X * added edge attachment command arg support
  495. X * 
  496. X * Revision 1.3  90/06/21  18:56:20  gringort
  497. X * added wsMotionEvents
  498. X * 
  499. X * Revision 1.2  90/06/07  13:31:33  gringort
  500. X * changes to init
  501. X * 
  502. X * Revision 1.1  90/04/23  14:45:52  gringort
  503. X * Initial revision
  504. X * 
  505. X *  
  506. X */
  507. X
  508. X#define NOMAPYET        (ColormapPtr) 1
  509. X
  510. X#define  ARG_DPIX    (1 << 0)
  511. X#define  ARG_DPIY    (1 << 1)
  512. X#define  ARG_DPI    (1 << 2)
  513. X#define  ARG_BLACKVALUE    (1 << 3)
  514. X#define  ARG_WHITEVALUE    (1 << 4)
  515. X#define     ARG_CLASS    (1 << 5)
  516. X#define     ARG_EDGE_L    (1 << 6)
  517. X#define     ARG_EDGE_R    (1 << 7)
  518. X#define     ARG_EDGE_T    (1 << 8)
  519. X#define     ARG_EDGE_B    (1 << 9)
  520. X#define  ARG_MONITOR    (1 << 10)
  521. X
  522. typedef struct  {
  523. X    int flags;
  524. X    int dpix;
  525. X    int dpiy;
  526. X    int dpi;
  527. X    int class;
  528. X    char  *blackValue;
  529. X    char  *whiteValue;
  530. X    int edge_left;
  531. X    int edge_right;
  532. X    int edge_top;
  533. X    int edge_bottom;
  534. X    ws_monitor monitor;
  535. X} ScreenArgsRec;
  536. X
  537. typedef struct {
  538. X    unsigned int        currentmask;     /* saved plane mask */
  539. X    BoxPtr            cursorConstraint;
  540. X    ws_screen_descriptor    *screenDesc;
  541. X    ColormapPtr        pInstalledMap;
  542. X    ScreenArgsRec         *args;
  543. X    Bool            (*CloseScreen)();
  544. X} wsScreenPrivate;
  545. X
  546. typedef struct {
  547. X    char *moduleID;    /* graphic module ID */
  548. X    Bool (*createProc)();    /* create procedure for this hardware type */
  549. X} wsAcceleratorTypes;
  550. X
  551. extern void wsStoreColors();
  552. extern void wsInstallColormap();
  553. extern void wsUninstallColormap();
  554. extern int wsListInstalledColormaps();
  555. extern int wsScreenPrivateIndex;
  556. extern Bool wsSaveScreen();
  557. extern int dpix, dpiy, dpi;
  558. X
  559. extern ScreenArgsRec screenArgs[];
  560. X
  561. extern ScreenPtr wsScreens[];
  562. extern int class;
  563. extern int fdPM;   /* this is the file descriptor for screen so
  564. X            can do IOCTL to colormap */
  565. extern int ws_cpu;
  566. X
  567. END_OF_FILE
  568. if test 3160 -ne `wc -c <'server/ddx/dec/ws/ws.h'`; then
  569.     echo shar: \"'server/ddx/dec/ws/ws.h'\" unpacked with wrong size!
  570. fi
  571. # end of 'server/ddx/dec/ws/ws.h'
  572. fi
  573. if test -f 'server/ddx/dec/ws/ws_color.c' -a "${1}" != "-c" ; then 
  574.   echo shar: Will not clobber existing file \"'server/ddx/dec/ws/ws_color.c'\"
  575. else
  576. echo shar: Extracting \"'server/ddx/dec/ws/ws_color.c'\" \(7788 characters\)
  577. sed "s/^X//" >'server/ddx/dec/ws/ws_color.c' <<'END_OF_FILE'
  578. X/***********************************************************
  579. Copyright 1991 by Digital Equipment Corporation, Maynard, Massachusetts,
  580. and the Massachusetts Institute of Technology, Cambridge, Massachusetts.
  581. X
  582. X                        All Rights Reserved
  583. X
  584. Permission to use, copy, modify, and distribute this software and its 
  585. documentation for any purpose and without fee is hereby granted, 
  586. provided that the above copyright notice appear in all copies and that
  587. both that copyright notice and this permission notice appear in 
  588. supporting documentation, and that the names of Digital or MIT not be
  589. used in advertising or publicity pertaining to distribution of the
  590. software without specific, written prior permission.  
  591. X
  592. DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  593. ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  594. DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  595. ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  596. WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  597. ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  598. SOFTWARE.
  599. X
  600. X******************************************************************/
  601. X/* $Header: /ath/p1/X11R4.mips/server/ddx/dec/ws/RCS/ws_color.c,v 1.2 91/05/21 10:55:09 jg Exp Locker: jg $ */
  602. X
  603. X/* 
  604. X * ws_color.c - device specific color routines, stored in screen
  605. X * 
  606. X * Author:    Jim Gettys
  607. X *         Digital Equipment Corporation
  608. X *         Cambridge Research Laboratory
  609. X * Date:    Sat January 24 1990
  610. X */
  611. X
  612. X/* $Log:    ws_color.c,v $
  613. X * Revision 1.2  91/05/21  10:55:09  jg
  614. X * fix from MIT
  615. X * 
  616. X * Revision 1.1  91/05/21  10:45:33  jg
  617. X * Initial revision
  618. X * 
  619. X * Revision 1.1  91/05/11  10:51:14  rws
  620. X * Initial revision
  621. X * 
  622. X * Revision 1.8  90/12/12  12:33:44  edg
  623. X * Added trick to wsInstallColormap() so that 8-bit TrueColor visual
  624. X * works on color frame buffer machines.  Merged in this change with
  625. X * earlier changes from WSE so all servers will work.
  626. X * 
  627. X * Revision 1.7  90/12/04  17:18:28  edg
  628. X * Added extra test so that StaticGray visuals get installed correctly.
  629. X * This is actually a work around for changes made by Joel G. for
  630. X * TurboChannel mfb.
  631. X * 
  632. X * Revision 1.6  90/11/27  13:55:58  kalmin
  633. X * in store colors, masked off pixel bit to create index for ioctl
  634. X * 
  635. X * Revision 1.5  90/11/26  15:25:16  kalmin
  636. X * added code to support 24 planes to InstallColormap
  637. X * 
  638. X * Revision 1.4  90/10/02  12:09:29  gringort
  639. X * fixed colormap init problems on monochrome screens
  640. X * 
  641. X * Revision 1.3  90/06/21  18:55:33  gringort
  642. X * added wsMotionEvents
  643. X * 
  644. X * Revision 1.2  90/05/11  16:57:11  gringort
  645. X *  snapshot works with monochrome
  646. X * 
  647. X * Revision 1.1  90/04/23  14:48:00  gringort
  648. X * Initial revision
  649. X * 
  650. X * Revision 1.6  90/02/27  18:24:30  jg
  651. X * fix for screen numbering, so that skipped screens should work.
  652. X * 
  653. X * Revision 1.5  90/02/25  12:59:49  jg
  654. X * more code cleanup.
  655. X * 
  656. X * Revision 1.3  90/02/19  17:50:18  jg
  657. X * fix implementation of StoreColors.
  658. X * 
  659. X * Revision 1.2  90/02/17  19:08:18  jg
  660. X * clean up naming.
  661. X * 
  662. X * Revision 1.1  90/02/16  16:55:56  jg
  663. X * Initial revision
  664. X *
  665. X */
  666. X
  667. X
  668. X
  669. static char rcs_ident[] = "$Header: /ath/p1/X11R4.mips/server/ddx/dec/ws/RCS/ws_color.c,v 1.2 91/05/21 10:55:09 jg Exp Locker: jg $";
  670. X
  671. X#include <stdio.h>
  672. X#include <sys/types.h>
  673. X#include <sys/file.h>
  674. X#include <sys/time.h>
  675. X#include <sys/tty.h>
  676. X#include <errno.h>
  677. X#include <sys/devio.h>
  678. X#include "X.h"          /* required for DoRed ... */
  679. X#include "Xproto.h"     /* required for xColorItem */
  680. X
  681. X#include "misc.h"       /* required for colormapst.h */
  682. X#include "resource.h"
  683. X#include "scrnintstr.h"
  684. X#include "colormapst.h"
  685. X/* XXX */
  686. X#include <sys/workstation.h>
  687. X
  688. X#include "ws.h"
  689. X
  690. X
  691. X
  692. X/* these next two are DIX routines */
  693. extern int      TellLostMap();
  694. extern int      TellGainedMap();
  695. X
  696. extern int wsFd;
  697. extern ws_screen_descriptor screenDesc[];
  698. X
  699. void
  700. wsStoreColors(pmap, ndef, pdefs)
  701. X    ColormapPtr pmap;
  702. X    int         ndef;
  703. X    xColorItem  *pdefs;
  704. X{
  705. X    xColorItem    directDefs[256];
  706. X    ws_color_cell cell;
  707. X    ws_color_map_data cd;
  708. X    wsScreenPrivate *pPrivScreen = (wsScreenPrivate *) 
  709. X    pmap->pScreen->devPrivates[wsScreenPrivateIndex].ptr;
  710. X    if (pmap != pPrivScreen->pInstalledMap) return;
  711. X
  712. X/* the following fixes a bug (in R5), but we aren't R5, so we lose anyway
  713. X#ifdef R5
  714. X    if ((pmap->pVisual->class | DynamicClass) == DirectColor)
  715. X    {
  716. X    ndef = cfbExpandDirectColors (pmap, ndef, pdefs, directDefs);
  717. X    pdefs = directDefs;
  718. X    }
  719. X#endif
  720. X    cd.screen = screenDesc[pmap->pScreen->myNum].screen;
  721. X    cd.map = 0;        /* only one... */
  722. X    cd.start = 0;
  723. X    cd.ncells = ndef;
  724. X    /* 
  725. X     * we will be evil, and note that the server and drive use the same
  726. X     * structure.
  727. X     */
  728. X    cd.cells = (ws_color_cell *)pdefs;
  729. X    if (ioctl(wsFd, WRITE_COLOR_MAP, &cd) == -1) {
  730. X    ErrorF("error writing color map\n");
  731. X    return;
  732. X    }
  733. X}
  734. X
  735. X#define _DUPRGB(C,V) ( (( (C) << (V)->offsetRed   ) & (V)->redMask  )\
  736. X              |(( (C) << (V)->offsetGreen ) & (V)->greenMask)\
  737. X              |(( (C) << (V)->offsetBlue  ) & (V)->blueMask ) )
  738. X
  739. void
  740. wsInstallColormap(pcmap)
  741. X    ColormapPtr    pcmap;
  742. X{
  743. X    int         entries = pcmap->pVisual->ColormapEntries;
  744. X    Pixel *     ppix;
  745. X    xrgb *      prgb;
  746. X    xColorItem *defs;
  747. X    int         i;
  748. X    wsScreenPrivate *pPrivScreen = (wsScreenPrivate *) 
  749. X      pcmap->pScreen->devPrivates[wsScreenPrivateIndex].ptr;
  750. X
  751. X    if (pcmap == pPrivScreen->pInstalledMap)  return;
  752. X    if ( pPrivScreen->pInstalledMap != NOMAPYET)
  753. X        WalkTree( pcmap->pScreen, TellLostMap, 
  754. X         &pPrivScreen->pInstalledMap->mid);
  755. X
  756. X    pPrivScreen->pInstalledMap = pcmap;
  757. X
  758. X    /* if Turbochannel mfb (2 entry StaticGray), do not store any colors */
  759. X    if (pcmap->class != StaticGray || entries != 2) {
  760. X
  761. X    /* If we have an 8 entry TrueColor map, then get all 256 pixel
  762. X        values so we can fake a TrueColor visual with an undecomposed
  763. X        hardware colormap (ie. devPriv == 0).
  764. X    */
  765. X    if (pcmap->devPriv == 0 && pcmap->class == TrueColor && entries == 8) {
  766. X        entries = 256;
  767. X    }
  768. X
  769. X    ppix = (Pixel *)ALLOCATE_LOCAL( entries * sizeof(Pixel));
  770. X    prgb = (xrgb *)ALLOCATE_LOCAL( entries * sizeof(xrgb));
  771. X    defs = (xColorItem *)ALLOCATE_LOCAL(entries * sizeof(xColorItem));
  772. X    
  773. X    /* devPriv == 1 means decomposed hardware colormap */
  774. X    if ((int) pcmap->devPriv == 1
  775. X        && ((pcmap->class | DynamicClass) == DirectColor))
  776. X        for( i = 0; i < entries; i++)
  777. X           ppix[i] = _DUPRGB( i, pcmap->pVisual);
  778. X    else
  779. X        for ( i=0; i<entries; i++)  ppix[i] = i;
  780. X
  781. X    QueryColors( pcmap, entries, ppix, prgb);
  782. X
  783. X    for ( i=0; i<entries; i++) { /* convert xrgbs to xColorItems */
  784. X        defs[i].pixel = ppix[i] & 0xff;      /* change pixel to index */
  785. X        defs[i].red = prgb[i].red;
  786. X        defs[i].green = prgb[i].green;
  787. X        defs[i].blue = prgb[i].blue;
  788. X        defs[i].flags =  DoRed|DoGreen|DoBlue;
  789. X    }
  790. X    wsStoreColors( pcmap, entries, defs);
  791. X    
  792. X    DEALLOCATE_LOCAL(ppix);
  793. X    DEALLOCATE_LOCAL(prgb);
  794. X    DEALLOCATE_LOCAL(defs);
  795. X    }
  796. X    WalkTree(pcmap->pScreen, TellGainedMap, &pcmap->mid);
  797. X}
  798. X
  799. X
  800. void
  801. wsUninstallColormap(pcmap)
  802. X    ColormapPtr pcmap;
  803. X{
  804. X    /*  Replace installed colormap with default colormap */
  805. X
  806. X    ColormapPtr defColormap;
  807. X    wsScreenPrivate *pPrivScreen = (wsScreenPrivate *) 
  808. X      pcmap->pScreen->devPrivates[wsScreenPrivateIndex].ptr;
  809. X
  810. X    if ( pcmap != pPrivScreen->pInstalledMap) return;
  811. X
  812. X    defColormap = (ColormapPtr) LookupIDByType( pcmap->pScreen->defColormap,
  813. X                        RT_COLORMAP);
  814. X
  815. X    if (defColormap == pPrivScreen->pInstalledMap) return;
  816. X
  817. X    (*pcmap->pScreen->InstallColormap) (defColormap);
  818. X}
  819. X
  820. int
  821. wsListInstalledColormaps( pscr, pcmaps)
  822. X    ScreenPtr   pscr;
  823. X    Colormap *  pcmaps;
  824. X{
  825. X    wsScreenPrivate *pPrivScreen = (wsScreenPrivate *) 
  826. X        pscr->devPrivates[wsScreenPrivateIndex].ptr;
  827. X    *pcmaps = pPrivScreen->pInstalledMap->mid;
  828. X    return 1;
  829. X}
  830. X
  831. END_OF_FILE
  832. if test 7788 -ne `wc -c <'server/ddx/dec/ws/ws_color.c'`; then
  833.     echo shar: \"'server/ddx/dec/ws/ws_color.c'\" unpacked with wrong size!
  834. fi
  835. # end of 'server/ddx/dec/ws/ws_color.c'
  836. fi
  837. if test -f 'server/ddx/dec/ws/ws_io.c' -a "${1}" != "-c" ; then 
  838.   echo shar: Will not clobber existing file \"'server/ddx/dec/ws/ws_io.c'\"
  839. else
  840. echo shar: Extracting \"'server/ddx/dec/ws/ws_io.c'\" \(34338 characters\)
  841. sed "s/^X//" >'server/ddx/dec/ws/ws_io.c' <<'END_OF_FILE'
  842. X/***********************************************************
  843. Copyright 1991 by Digital Equipment Corporation, Maynard, Massachusetts,
  844. and the Massachusetts Institute of Technology, Cambridge, Massachusetts.
  845. X
  846. X                        All Rights Reserved
  847. X
  848. Permission to use, copy, modify, and distribute this software and its 
  849. documentation for any purpose and without fee is hereby granted, 
  850. provided that the above copyright notice appear in all copies and that
  851. both that copyright notice and this permission notice appear in 
  852. supporting documentation, and that the names of Digital or MIT not be
  853. used in advertising or publicity pertaining to distribution of the
  854. software without specific, written prior permission.  
  855. X
  856. DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  857. ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  858. DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  859. ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  860. WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  861. ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  862. SOFTWARE.
  863. X
  864. X******************************************************************/
  865. X
  866. X/* $Header: ws_io.c,v 1.1 91/05/11 10:51:16 rws Exp $ */
  867. X
  868. X#include <stdio.h>
  869. X#include <sys/types.h>
  870. X#include <sys/file.h>
  871. X#include <sys/time.h>
  872. X#include <sys/tty.h>
  873. X#include <sys/stat.h>
  874. X#include <errno.h>
  875. X#include <sys/devio.h>
  876. X#define  NEED_EVENTS
  877. X#include "misc.h"
  878. X#include "X.h"
  879. X#include "Xproto.h"
  880. X#include "scrnintstr.h"
  881. X#include "pixmap.h"
  882. X#include "inputstr.h"
  883. X#include "cursorstr.h"
  884. X#include "regionstr.h"
  885. X#include "resource.h"
  886. X#include "dixstruct.h"
  887. X#include <sys/workstation.h>
  888. X#include <sys/inputdevice.h>
  889. X#include <sys/wsdevice.h>
  890. X#include "ws.h"
  891. X#include "keynames.h"
  892. X
  893. X
  894. X#include "mi.h"
  895. X
  896. X#define MOTION_BUFFER_SIZE 100
  897. X
  898. extern ws_descriptor wsinfo;
  899. void wsCursorControl();
  900. X
  901. extern ws_screen_descriptor screenDesc[];
  902. extern int wsFd;
  903. int rememberedScreen;
  904. static int shiftLock;
  905. static short lockLed;
  906. ScreenPtr    wsScreens[MAXSCREENS];
  907. ScreenArgsRec    screenArgs[MAXSCREENS];
  908. static DevicePtr    wsPointer;
  909. static DevicePtr    wsKeyboard;
  910. char *blackValue, *whiteValue;
  911. extern    ws_event_queue    *queue;
  912. int lastEventTime;
  913. int wsNumButtons = -1;
  914. X
  915. X#define MAX_LED 3    /* only 3 LED's can be set by user; Lock LED
  916. X               is controlled by server */
  917. X
  918. X#define VSYNCFIXED
  919. X#ifdef VSYNCFIXED
  920. X#define CURRENT_TIME    queue->time
  921. X#else
  922. X#define CURRENT_TIME    GetTimeInMillis()
  923. X#endif
  924. X
  925. X#define NoSuchClass -1
  926. X
  927. static int
  928. ParseClass(className)
  929. X    char *    className;
  930. X{
  931. X    static char *names[] = {
  932. X    "StaticGray", 
  933. X    "GrayScale", 
  934. X    "StaticColor",
  935. X    "PseudoColor", 
  936. X    "TrueColor"};
  937. X    /* 
  938. X     * only the ones we support and must be in order from X.h, since
  939. X     * return value depends on index into array.
  940. X     */
  941. X    int i;
  942. X    for (i = 0; i < sizeof(names)/sizeof(char *); i++)
  943. X    {
  944. X    if (strcmp(names[i], className) == 0)
  945. X        return i;
  946. X    }
  947. X    return NoSuchClass;
  948. X}
  949. X
  950. X/* SaveScreen does blanking, so no need to worry about the interval timer */
  951. X
  952. Bool
  953. wsSaveScreen(pScreen, on)
  954. X    ScreenPtr pScreen;
  955. X    int on;
  956. X{
  957. X    ws_video_control vc;
  958. X    vc.screen = screenDesc[pScreen->myNum].screen;
  959. X
  960. X    if (on == SCREEN_SAVER_FORCER) {
  961. X    lastEventTime = GetTimeInMillis();
  962. X    } else if (on == SCREEN_SAVER_ON) {
  963. X    vc.control = SCREEN_OFF;
  964. X    if (ioctl(wsFd, VIDEO_ON_OFF, &vc) < 0)
  965. X        ErrorF("VIDEO_ON_OFF: failed to turn screen off.\n");
  966. X    } else {
  967. X        lastEventTime = GetTimeInMillis();    
  968. X    vc.control = SCREEN_ON;
  969. X    if (ioctl(wsFd, VIDEO_ON_OFF, &vc) < 0)
  970. X        ErrorF("VIDEO_ON_OFF: failed to turn screen on.\n");
  971. X    }
  972. X    return TRUE;
  973. X}
  974. X
  975. X
  976. wsPixelError(index)
  977. int index;
  978. X{
  979. X    ErrorF("Only 0 through 255 are acceptable pixels for device %d\n", index);
  980. X}
  981. X
  982. void
  983. wsClick(click)
  984. X    int         click;
  985. X{
  986. X    ws_keyboard_control control;
  987. X    control.device_number = wsinfo.console_keyboard;
  988. X    control.flags = WSKBKeyClickPercent;
  989. X    control.click = click;
  990. X    if (ioctl (wsFd, SET_KEYBOARD_CONTROL, &control) == -1)
  991. X      printf ("couldn't set click\n");
  992. X    return;
  993. X}
  994. X
  995. static void
  996. wsChangeKeyboardControl(device, ctrl)
  997. X    DevicePtr device;
  998. X    KeybdCtrl *ctrl;
  999. X{
  1000. X    int i;
  1001. X    ws_keyboard_control control;
  1002. X    control.device_number = wsinfo.console_keyboard;
  1003. X    control.flags = 0;
  1004. X
  1005. X    /* 
  1006. X     * even though some of these are not implemented on the lk201/lk401,
  1007. X     * we should pass these to the driver, as other hardware may not
  1008. X     * lose so badly.  The new driver does do auto-repeat and up down
  1009. X     * properly, however.
  1010. X     */
  1011. X    control.flags |=  WSKBKeyClickPercent| WSKBBellPercent | WSKBBellPitch | 
  1012. X    WSKBBellDuration | WSKBAutoRepeatMode | WSKBAutoRepeats | WSKBLed;
  1013. X    control.click = ctrl->click;
  1014. X    control.bell = ctrl->bell;
  1015. X    control.bell_pitch = ctrl->bell_pitch;
  1016. X    control.bell_duration = ctrl->bell_duration;
  1017. X    control.auto_repeat = ctrl->autoRepeat;
  1018. X    control.leds = ctrl->leds;
  1019. X    /* 
  1020. X     * XXX a crock, but to have a byte interface would have implied the
  1021. X     * driver did alot more work at interrupt time, so we made it 32 bits wide.
  1022. X     */
  1023. X    bcopy(ctrl->autoRepeats, control.autorepeats, 32);
  1024. X#ifdef notdef
  1025. X    /* LEDs */
  1026. X    for (i=1; i<=MAX_LED; i++)
  1027. X        ChangeLED(i, (ctrl->leds & (1 << (i-1))));
  1028. X#endif
  1029. X    if (ioctl (wsFd, SET_KEYBOARD_CONTROL, &control) == -1)
  1030. X      printf ("couldn't set global autorepeat\n");
  1031. X    return;
  1032. X
  1033. X}
  1034. X
  1035. static void
  1036. wsBell(loud, pDevice)
  1037. X    int loud;
  1038. X    DevicePtr pDevice;
  1039. X{
  1040. X    ws_keyboard_control control;
  1041. X    control.device_number = wsinfo.console_keyboard;
  1042. X    control.flags = WSKBBellPercent;
  1043. X    control.bell = loud;
  1044. X    ioctl(wsFd, SET_KEYBOARD_CONTROL, &control);
  1045. X
  1046. X    ioctl(wsFd, RING_KEYBOARD_BELL, &wsinfo.console_keyboard);
  1047. X}
  1048. X
  1049. X/*
  1050. X * These serve protocol requests, setting/getting acceleration and threshold.
  1051. X * X10 analog is "SetMouseCharacteristics".
  1052. X */
  1053. void
  1054. wsChangePointerControl(device, ctrl)
  1055. X    DevicePtr device;
  1056. X    PtrCtrl   *ctrl;
  1057. X{
  1058. X    ws_pointer_control pc;
  1059. X    pc.device_number = wsinfo.console_pointer;
  1060. X    pc.numerator = ctrl->num;
  1061. X    pc.denominator = ctrl->den;
  1062. X    pc.threshold = ctrl->threshold;
  1063. X    if (ioctl (wsFd, SET_POINTER_CONTROL, &pc) == -1) {
  1064. X    ErrorF ("error setting mouse properties\n");
  1065. X    }
  1066. X}
  1067. X
  1068. int
  1069. wsGetMotionEvents(pDevice, buff, start, stop)
  1070. X    CARD32 start, stop;
  1071. X    DevicePtr pDevice;
  1072. X    xTimecoord *buff;
  1073. X{
  1074. X    register int    i;        /* Number of events left to process in ring */
  1075. X    ws_motion_buffer *mb = queue->mb;
  1076. X    register ws_motion_history *mh = mb->motion; /*Beginning of ring storage*/
  1077. X    int            count;      /* Number of events that match conditions   */
  1078. X    CARD32 temptime;
  1079. X
  1080. X    /* Loop through entire ring buffer.  Technically, the driver may not have
  1081. X       actually queued this many motion events, but since they are initialized
  1082. X       to time 0 the non-events shouldn't match.  If the mouse isn't moved for
  1083. X       25 days after startup this could be a problem...but who cares? */
  1084. X    count = 0;
  1085. X    for (i = mb->size; i != 0; i--) {
  1086. X    temptime = mh->time;
  1087. X    if (start <= temptime && temptime <= stop) {
  1088. X        buff[count].time = temptime;
  1089. X        buff[count].x    = mh->axis[0];
  1090. X        buff[count].y    = mh->axis[1];
  1091. X        if (temptime == mh->time) count++;    /* paranoid */
  1092. X    }
  1093. X    mh = (ws_motion_history *) ((int)mh + mb->entry_size);
  1094. X    } 
  1095. X    return count;
  1096. X}
  1097. X
  1098. int
  1099. wsMouseProc(pDev, onoff, argc, argv)
  1100. X    DevicePtr pDev;
  1101. X    int onoff, argc;
  1102. X    char *argv[];
  1103. X{
  1104. X    int     i, numButtons;
  1105. X    BYTE    map[6];
  1106. X    ws_hardware_type wht;
  1107. X
  1108. X    switch (onoff)
  1109. X    {
  1110. X    case DEVICE_INIT: 
  1111. X        wht.device_number = wsinfo.console_pointer;
  1112. X        ioctl(wsFd, GET_DEVICE_TYPE, &wht);
  1113. X        wsPointer = pDev;
  1114. X        pDev->devicePrivate = (pointer) &queue;
  1115. X        map[1] = 1;  /* worst case is 5 buttons  - jmg */
  1116. X        map[2] = 2;
  1117. X        map[3] = 3;
  1118. X        map[4] = 4;
  1119. X        map[5] = 5;
  1120. X        if(wsNumButtons == -1) {
  1121. X        if(wht.hardware_type == VSXXX)
  1122. X            numButtons = 3;
  1123. X        else 
  1124. X            numButtons = 4;
  1125. X        } 
  1126. X        else
  1127. X        numButtons = wsNumButtons;
  1128. X        InitPointerDeviceStruct(
  1129. X        wsPointer, map, numButtons, wsGetMotionEvents,
  1130. X        wsChangePointerControl, MOTION_BUFFER_SIZE);
  1131. X        SetInputCheck(&queue->head, &queue->tail);
  1132. X        break;
  1133. X    case DEVICE_ON: 
  1134. X        pDev->on = TRUE;
  1135. X        AddEnabledDevice(wsFd); 
  1136. X        break;
  1137. X    case DEVICE_OFF: 
  1138. X        pDev->on = FALSE;
  1139. X        RemoveEnabledDevice(wsFd);
  1140. X        break;
  1141. X    case DEVICE_CLOSE:
  1142. X        break;
  1143. X    }
  1144. X    return Success;
  1145. X}
  1146. X
  1147. X/* since this driver does up/down autorepeat right, any key can be a modifier*/
  1148. Bool
  1149. LegalModifier(key)
  1150. X    BYTE key;
  1151. X{
  1152. X    return TRUE;
  1153. X
  1154. X}
  1155. X
  1156. int
  1157. wsKeybdProc(pDev, onoff, argc, argv)
  1158. X    DevicePtr pDev;
  1159. X    int onoff, argc;
  1160. X    char *argv[];
  1161. X{
  1162. X    KeySymsRec keySyms;
  1163. X    CARD8 modMap[MAP_LENGTH];
  1164. X
  1165. X    switch (onoff)
  1166. X    {
  1167. X    case DEVICE_INIT: 
  1168. X/* Note that keyclick is off by default.  The QDSS MIT server sets it
  1169. X   to 20 */    
  1170. X        wsKeyboard = pDev;
  1171. X        GetKeyboardMappings( &keySyms, modMap);
  1172. X        InitKeyboardDeviceStruct(
  1173. X            wsKeyboard, &keySyms, modMap, wsBell,
  1174. X            wsChangeKeyboardControl);
  1175. X    /* Free the key sym mapping space allocated by GetKeyboardMappings. */
  1176. X        Xfree(keySyms.map);  
  1177. X        break;
  1178. X    case DEVICE_ON: 
  1179. X        pDev->on = TRUE;
  1180. X        AddEnabledDevice(wsFd); 
  1181. X        break;
  1182. X    case DEVICE_OFF: 
  1183. X        pDev->on = FALSE;
  1184. X        RemoveEnabledDevice(wsFd);
  1185. X        break;
  1186. X    case DEVICE_CLOSE: 
  1187. X        break;
  1188. X    }
  1189. X    return Success;
  1190. X}
  1191. extern int screenIsSaved;
  1192. static CursorPtr    currentCursor;
  1193. X
  1194. X
  1195. X/* The code below is for backward compatibility with DEC R3 servers.
  1196. X * Load the keyboard map pointed to by the file "/usr/lib/X11/keymap_default"
  1197. X */
  1198. X
  1199. X#define FileNameLength 256
  1200. X#define MaxLineLength 256
  1201. X
  1202. X
  1203. KeySym *LoadKeymap();
  1204. X
  1205. X/*
  1206. X * Load the default keymap file.
  1207. X */
  1208. X
  1209. int GetDefaultMap(ks)
  1210. X    KeySymsPtr ks;
  1211. X{
  1212. X    char keymap_name[FileNameLength];
  1213. X    KeySym *keymap_pointer;
  1214. X    int keymap_width;
  1215. X    int keymap_loaded = FALSE;
  1216. X
  1217. X    if (GetKeymapName (keymap_name)==TRUE) {
  1218. X    if ((keymap_pointer = LoadKeymap (keymap_name, MIN_LK201_KEY,
  1219. X                    MAX_LK201_KEY, &keymap_width)) !=NULL) {
  1220. X        ks->minKeyCode = MIN_LK201_KEY;
  1221. X        ks->maxKeyCode = MAX_LK201_KEY;
  1222. X        ks->mapWidth = keymap_width;
  1223. X        ks->map = keymap_pointer;
  1224. X        keymap_loaded=TRUE;
  1225. X    }
  1226. X    }
  1227. X    return (keymap_loaded);
  1228. X}
  1229. X
  1230. X
  1231. X/*
  1232. X * Check for keymap type file "/usr/lib/X11/keymap_default"
  1233. X */
  1234. X
  1235. int GetKeymapName (name_return)
  1236. X    char *name_return;
  1237. X{
  1238. X    char *filename = "/usr/lib/X11/keymap_default";
  1239. X    int fd;
  1240. X    int len;
  1241. X
  1242. X    if ((fd = open(filename, O_RDONLY)) == -1)
  1243. X    return (FALSE);
  1244. X    len = strlen(filename);
  1245. X    strcpy(name_return, filename);
  1246. X    name_return[len] = '\0';
  1247. X    return (TRUE);
  1248. X}
  1249. X
  1250. X
  1251. X#define EndLine(c) (((c)=='!' || (c) =='\n' || (c) == '\0') ? TRUE : FALSE )
  1252. X
  1253. X/*
  1254. X * load the keymap file into  keysym table
  1255. X */
  1256. X
  1257. KeySym *LoadKeymap(keymap_name, minkc, maxkc, return_ks_per_kc)
  1258. X    char *keymap_name;
  1259. X    KeyCode minkc;
  1260. X    KeyCode maxkc;
  1261. X    int *return_ks_per_kc;
  1262. X{
  1263. X    FILE *fp;
  1264. X    KeySym *keymap = NULL;
  1265. X    char line[MaxLineLength];
  1266. X
  1267. X    if ((fp=fopen (keymap_name, "r")) == NULL)
  1268. X    return ( (KeySym *) NULL);
  1269. X
  1270. X    while (fgets (line, MaxLineLength, fp) != NULL) {
  1271. X    if (AddLineToKeymap (line, &keymap, minkc, maxkc, return_ks_per_kc)
  1272. X                                ==FALSE) {
  1273. X        fclose (fp);
  1274. X        if (keymap != NULL) Xfree (keymap);
  1275. X        return ( (KeySym *)NULL);
  1276. X    }
  1277. X    }
  1278. X    fclose (fp);
  1279. X    return ( keymap );
  1280. X}    
  1281. X
  1282. X
  1283. X/*
  1284. X * decode keycode, and keysyms from line, allocate keymap first time round.
  1285. X */
  1286. X
  1287. int AddLineToKeymap (line, keymap, minkc, maxkc, return_ncols)
  1288. X    char *line;
  1289. X    KeySym **keymap;
  1290. X    KeyCode minkc;
  1291. X    KeyCode maxkc;
  1292. X    int *return_ncols;
  1293. X{
  1294. X    int pos;
  1295. X    KeyCode kc;
  1296. X    KeySym *offset;
  1297. X    KeySym ks;
  1298. X    int ncols;
  1299. X    int col;
  1300. X    int map_size;
  1301. X    int i;
  1302. X
  1303. X    if (isspace(line[0]) || line[0] == '!' || line[0] == '\n' || line[0] == '\0')
  1304. X    return (TRUE); /* ignore blank lines and comments */
  1305. X
  1306. X    if ( *keymap ==NULL) {
  1307. X    pos=0;
  1308. X    if ((kc=GetToken (line, &pos)) == -1) return (FALSE);
  1309. X    ncols=0;
  1310. X    while (GetToken (line, &pos) != -1)
  1311. X        ncols++;
  1312. X    if (ncols < 2) ncols = 2;
  1313. X    (*return_ncols) = ncols;
  1314. X    map_size = (maxkc-minkc+1) * ncols;
  1315. X    (*keymap) = (KeySym *) Xalloc ( map_size * sizeof (KeySym));
  1316. X    for (i = 0; i < map_size; i++)
  1317. X        (*keymap)[i] = NoSymbol;
  1318. X
  1319. X    }
  1320. X    pos = 0;
  1321. X    if ((kc=GetToken (line, &pos)) == -1) return (FALSE);
  1322. X    if ( kc < minkc || kc > maxkc ) return (FALSE);
  1323. X    offset = (*keymap) + (kc-minkc)* (*return_ncols);
  1324. X    col=0;
  1325. X    while (col < (*return_ncols) && ((ks=GetToken (line, &pos)) != -1)) {
  1326. X    *(offset + col) = ks;
  1327. X    col+=1;
  1328. X    }
  1329. X    return (TRUE);
  1330. X}
  1331. X
  1332. X/*
  1333. X * return hex value of next item on line (current position held in 'pos')
  1334. X */
  1335. X
  1336. int GetToken (line, pos)
  1337. X    char *line;
  1338. X    int *pos;
  1339. X{
  1340. X    int start;
  1341. X
  1342. X    if (EndLine(line[*pos]) == TRUE) return (-1);
  1343. X    while (isspace(line[*pos]) || EndLine(line[*pos])) {
  1344. X    if (EndLine(line[*pos]) == TRUE)
  1345. X        return (-1);
  1346. X    (*pos)++;
  1347. X    }
  1348. X    start = *pos;
  1349. X    while (!isspace (line[*pos]) && !EndLine (line[*pos])) {
  1350. X    (*pos)++;
  1351. X    }
  1352. X    return (StringToHex(&line[start], (*pos)-start));
  1353. X}
  1354. X
  1355. X
  1356. X/*
  1357. X * convert null terminated hexadecimal string to integer
  1358. X * return 'value', or '-1' on error
  1359. X */
  1360. X
  1361. int StringToHex (str,nbytes)
  1362. X    char *str;
  1363. X    int nbytes;
  1364. X{
  1365. X    int i;
  1366. X    int digit;
  1367. X    int scale = 1;
  1368. X    long value = 0;
  1369. X
  1370. X    for (i=nbytes-1;i>=0;i--) {
  1371. X    if (!isxdigit(str[i])) return (-1);
  1372. X    if (isdigit(str[i]))
  1373. X        digit=str[i]-'0';
  1374. X    else
  1375. X        digit=toupper(str[i])-'A'+10;
  1376. X    value+=(digit*scale);
  1377. X    scale*=16;
  1378. X    }
  1379. X    return(value);
  1380. X}
  1381. X
  1382. X#undef EndLine
  1383. X#undef MaxLineLength
  1384. X#undef FileNameLength
  1385. X
  1386. X
  1387. Bool GetKeyboardMappings(pKeySyms, pModMap)
  1388. X    KeySymsPtr pKeySyms;
  1389. X    CARD8 *pModMap;
  1390. X{
  1391. X    int i;
  1392. X    ws_keyboard_definition def;
  1393. X    KeySym *map;
  1394. X    KeySym rawsyms[256];        /* more than we'll ever need! */
  1395. X    unsigned char rawcodes[256];    /* more than we'll ever need! */
  1396. X    ws_keycode_modifiers mods[32];    /* more than we'll ever need! */
  1397. X    ws_keysyms_and_modifiers km;
  1398. X    int min_keycode = 256, max_keycode = 0;
  1399. X
  1400. X    /* If it exists, load special keysym map from file instead of driver.
  1401. X    This is for backward compatibility with the i18n stuff from the
  1402. X    DEC R3 servers.
  1403. X    */
  1404. X    if (GetDefaultMap(pKeySyms) == TRUE) {
  1405. X    for (i = 0; i < MAP_LENGTH; i++)
  1406. X        pModMap[i] = NoSymbol;    /* make sure it is restored */
  1407. X    pModMap[ KEY_LOCK ] = LockMask;
  1408. X    pModMap[ KEY_SHIFT ] = ShiftMask;
  1409. X    pModMap[ KEY_SHIFT_R ] = ShiftMask;
  1410. X    pModMap[ KEY_CTRL ] = ControlMask;
  1411. X    pModMap[ KEY_COMPOSE ] = Mod1Mask;
  1412. X    pModMap[ KEY_COMPOSE_R ] = Mod1Mask;
  1413. X    pModMap[ KEY_ALT_L ] = Mod2Mask;
  1414. X    pModMap[ KEY_ALT_R ] = Mod2Mask;
  1415. X    return (TRUE);
  1416. X    }
  1417. X
  1418. X    def.device_number = wsinfo.console_keyboard;
  1419. X    if (ioctl (wsFd, GET_KEYBOARD_DEFINITION, &def) == -1) {
  1420. X    ErrorF ("error getting keyboard definition\n");
  1421. X    }
  1422. X    lockLed = def.lock_key_led;
  1423. X    km.device_number = wsinfo.console_keyboard;
  1424. X    km.modifiers = mods;
  1425. X    km.keysyms = rawsyms;
  1426. X    km.keycodes = rawcodes;
  1427. X    if (ioctl (wsFd, GET_KEYSYMS_AND_MODIFIERS, &km) == -1) {
  1428. X    ErrorF ("error getting keysyms and modifiers\n");
  1429. X    }
  1430. X
  1431. X#define KEYCODE(i) ((i) >> 24))
  1432. X    for (i = 0; i < def.keysyms_present; i++) {
  1433. X    if (rawcodes[i] > max_keycode) max_keycode = rawcodes[i];
  1434. X    if (rawcodes[i] < min_keycode) min_keycode = rawcodes[i];
  1435. X    }
  1436. X    
  1437. X    map = (KeySym *)Xalloc(sizeof(KeySym) * 
  1438. X            (MAP_LENGTH * def.keysyms_per_keycode));
  1439. X    if (!map)
  1440. X    return FALSE;
  1441. X
  1442. X    for (i = 0; i < MAP_LENGTH; i++)
  1443. X    pModMap[i] = NoSymbol;    /* make sure it is restored */
  1444. X
  1445. X    /* first set up modifier keys */
  1446. X    for (i = 0; i < def.modifier_keycode_count; i++)
  1447. X    pModMap[mods[i].keycode] = mods[i].modbits;
  1448. X
  1449. X    /* initialize the keysym array */
  1450. X    for (i = 0; i < (MAP_LENGTH * def.keysyms_per_keycode); i++)
  1451. X    map[i] = NoSymbol;
  1452. X    pKeySyms->minKeyCode = min_keycode;
  1453. X    pKeySyms->maxKeyCode = max_keycode;
  1454. X    pKeySyms->mapWidth   = def.keysyms_per_keycode;
  1455. X    pKeySyms->map = map;
  1456. X#define INDEX(in) ((in - min_keycode) * def.keysyms_per_keycode)
  1457. X    for (i = 0; i < def.keysyms_present; i++) {
  1458. X    register int j;
  1459. X    for (j = 0; j < def.keysyms_per_keycode; j++) {
  1460. X        if (map[INDEX(rawcodes[i]) + j] == NoSymbol) {
  1461. X            map[INDEX(rawcodes[i]) + j] = rawsyms[i];
  1462. X            break;
  1463. X        }
  1464. X    }
  1465. X    }
  1466. X#undef INDEX
  1467. X    return TRUE;
  1468. X}
  1469. X
  1470. X
  1471. void
  1472. SetLockLED (on)
  1473. X    Bool on;
  1474. X{
  1475. X    ws_keyboard_control kc;
  1476. X    kc.flags = WSKBLed;
  1477. X    kc.device_number = wsinfo.console_keyboard;
  1478. X    if (ioctl (wsFd, GET_KEYBOARD_CONTROL, &kc) == -1) {
  1479. X        ErrorF ("error getting keyboard control\n");
  1480. X    }
  1481. X    if(on)
  1482. X        kc.leds |= 1 << (lockLed -1);
  1483. X    else
  1484. X    kc.leds &= ~(1 << (lockLed -1));
  1485. X    kc.flags = WSKBLed;
  1486. X    if (ioctl (wsFd, SET_KEYBOARD_CONTROL, &kc) == -1) {
  1487. X        ErrorF ("error setting keyboard control\n");
  1488. X    }
  1489. X}
  1490. X
  1491. X/*
  1492. X * The driver has been set up to put events in the queue that are identical
  1493. X * in shape to the events that the DDX layer has to deliver to ProcessInput
  1494. X * in DIX.
  1495. X */
  1496. void
  1497. ProcessInputEvents()
  1498. X{
  1499. X    xEvent x;
  1500. X    register ws_event *e;
  1501. X    register int    i;
  1502. X    int screen;
  1503. X    DeviceIntPtr dev = (DeviceIntPtr) wsKeyboard;
  1504. X    i = queue->head;
  1505. X    while (i != queue->tail)  {
  1506. X    e = (ws_event *)((int)(queue->events) + queue->event_size * i);
  1507. X
  1508. X    if (screenIsSaved == SCREEN_SAVER_ON)
  1509. X        SaveScreens(SCREEN_SAVER_OFF, ScreenSaverReset);
  1510. X       if(e->screen != rememberedScreen)
  1511. X    {
  1512. X        ScreenPtr    pScreen;
  1513. X        short        x, y;
  1514. X
  1515. X        /* assumption -- this is a motion event */
  1516. X        wsCursorControl(rememberedScreen, CURSOR_OFF);
  1517. X        wsCursorControl(e->screen, CURSOR_ON);
  1518. X        rememberedScreen = e->screen;
  1519. X        pScreen = wsScreens[e->screen];
  1520. X        if (currentCursor)
  1521. X            wsDisplayCursor (pScreen, currentCursor);
  1522. X        x = e->e.key.x;
  1523. X        y = e->e.key.y;
  1524. X        if (i >= queue->size - 1)   i = queue->head = 0;
  1525. X        else                i = ++queue->head;
  1526. X        NewCurrentScreen(pScreen, x, y);
  1527. X        i = queue->head;
  1528. X        continue;
  1529. X        }
  1530. X
  1531. X    x.u.keyButtonPointer.rootX = e->e.key.x;
  1532. X    x.u.keyButtonPointer.rootY = e->e.key.y;
  1533. X    x.u.keyButtonPointer.time = lastEventTime = e->time;
  1534. X    x.u.u.detail = e->e.key.key;
  1535. X
  1536. X    switch (e->device_type) {
  1537. X      case KEYBOARD_DEVICE:
  1538. X            switch (e->type) {
  1539. X            case BUTTON_DOWN_TYPE: 
  1540. X                x.u.u.type = KeyPress;
  1541. X                /* if key is a lock modifier then ... */
  1542. X                if (dev->key->modifierMap[e->e.key.key] & LockMask){
  1543. X                if (shiftLock) {
  1544. X                    x.u.u.type = KeyRelease;
  1545. X                    SetLockLED (FALSE);
  1546. X                    shiftLock = FALSE;
  1547. X                } else {
  1548. X                    x.u.u.type = KeyPress;
  1549. X                    SetLockLED (TRUE);
  1550. X                    shiftLock = TRUE;
  1551. X                }
  1552. X                }
  1553. X                (*wsKeyboard->processInputProc) 
  1554. X                (&x, wsKeyboard, 1);
  1555. X                break;
  1556. X            case BUTTON_UP_TYPE: 
  1557. X                /* if key is a lock modifier then ignore */
  1558. X                if (dev->key->modifierMap[e->e.key.key] & LockMask)
  1559. X                break;
  1560. X                x.u.u.type = KeyRelease;
  1561. X                (*wsKeyboard->processInputProc)
  1562. X                (&x, wsKeyboard, 1);
  1563. X                break;
  1564. X            default:            /* hopefully BUTTON_RAW_TYPE */
  1565. X                break;
  1566. X            }
  1567. X            break;
  1568. X        case MOUSE_DEVICE:
  1569. X        /* someday tablet will be handled differently than a mouse */
  1570. X        case TABLET_DEVICE:
  1571. X            switch (e->type) {
  1572. X            case BUTTON_DOWN_TYPE: 
  1573. X                x.u.u.type = ButtonPress;
  1574. X                break;
  1575. X            case BUTTON_UP_TYPE: 
  1576. X                x.u.u.type = ButtonRelease;
  1577. X                break;
  1578. X            case MOTION_TYPE: 
  1579. X                x.u.u.type = MotionNotify;
  1580. X                break;
  1581. X            default: 
  1582. X#ifdef DEBUG
  1583. X                printf("Unknown mouse or tablet event = %d\n",
  1584. X                e->type);
  1585. X#endif
  1586. X                goto out;
  1587. X            }
  1588. X            (*wsPointer->processInputProc) (&x, wsPointer, 1);
  1589. X            break;
  1590. X        /* new input devices go here (or are ignored) */
  1591. X        default:
  1592. X#ifdef XINPUT
  1593. X            if (!ExtProcessInputEvents(&x, e))
  1594. X#  ifdef DEBUG
  1595. X              printf("Unknown device type = %d\n",e->device_type);
  1596. X#  else
  1597. X              ; /* do nothing */
  1598. X#  endif
  1599. X#else
  1600. X#  ifdef DEBUG
  1601. X            printf("Unknown device type = %d\n",e->device_type);
  1602. X#  endif
  1603. X#endif
  1604. X        break;
  1605. X    }
  1606. out:
  1607. X    if (i >= queue->size - 1)   i = queue->head = 0;
  1608. X    else                i = ++queue->head;
  1609. X
  1610. X    }
  1611. X}
  1612. X
  1613. TimeSinceLastInputEvent()
  1614. X{
  1615. X    if (lastEventTime == 0)
  1616. X    lastEventTime = CURRENT_TIME;
  1617. X    return CURRENT_TIME -  lastEventTime;
  1618. X}
  1619. X
  1620. extern Bool PointerConfinedToScreen();
  1621. X/*
  1622. X * set the bounds in the device for this particular cursor
  1623. X */
  1624. static void
  1625. wsConstrainCursor( pScr, pBox)
  1626. X    ScreenPtr    pScr;
  1627. X    BoxPtr    pBox;
  1628. X{
  1629. X    ws_pointer_box wsbox;
  1630. X    wsbox.screen = screenDesc[pScr->myNum].screen;
  1631. X    wsbox.enable = PointerConfinedToScreen();
  1632. X    wsbox.device_number = wsinfo.console_pointer;
  1633. X    wsbox.box.bottom = pBox->y2;
  1634. X    wsbox.box.right = pBox->x2;
  1635. X    wsbox.box.top = pBox->y1;
  1636. X    wsbox.box.left = pBox->x1;
  1637. X
  1638. X    if (ioctl(wsFd, SET_POINTER_BOX, &wsbox) == -1)
  1639. X        ErrorF("SET_POINTER_BOX: failed to set pointer box.\n");
  1640. X}
  1641. X
  1642. static Bool
  1643. wsSetCursorPosition( pScr, newx, newy, generateEvent)
  1644. X    ScreenPtr    pScr;
  1645. X    unsigned int    newx;
  1646. X    unsigned int    newy;
  1647. X    Bool        generateEvent;
  1648. X{
  1649. X    ws_pointer_position pos;
  1650. X    xEvent motion;
  1651. X
  1652. X    pos.screen = screenDesc[pScr->myNum].screen;
  1653. X    pos.device_number = wsinfo.console_pointer;
  1654. X    pos.x = newx;
  1655. X    pos.y = newy;
  1656. X
  1657. X    /* if this is on a different screen, then we need to switch... */
  1658. X    if (pos.screen != rememberedScreen) {
  1659. X        wsCursorControl(rememberedScreen, CURSOR_OFF);
  1660. X        wsCursorControl(pos.screen, CURSOR_ON);
  1661. X        rememberedScreen = pos.screen;
  1662. X    }
  1663. X    if (ioctl (wsFd, SET_POINTER_POSITION, &pos) == -1) {
  1664. X    ErrorF ("error warping cursor\n");
  1665. X    return FALSE;
  1666. X    }
  1667. X
  1668. X    if (generateEvent) {
  1669. X    if (queue->head != queue->tail)
  1670. X        ProcessInputEvents ();
  1671. X    motion.u.keyButtonPointer.rootX = newx;
  1672. X    motion.u.keyButtonPointer.rootY = newy;
  1673. X    motion.u.keyButtonPointer.time = currentTime.milliseconds;
  1674. X    motion.u.u.type = MotionNotify;
  1675. X    (wsPointer->processInputProc)(&motion, wsPointer, 1);
  1676. X    }
  1677. X    return TRUE;
  1678. X}
  1679. X
  1680. static Bool
  1681. wsDisplayCursor( pScr, pCurs)
  1682. X    ScreenPtr    pScr;
  1683. X    CursorPtr    pCurs;
  1684. X{
  1685. X    ws_cursor_data cd;
  1686. X    ws_cursor_color cc;
  1687. X    cd.screen = screenDesc[pScr->myNum].screen;
  1688. X    cd.width = pCurs->bits->width;
  1689. X    cd.height = pCurs->bits->height;
  1690. X    cd.x_hot =  pCurs->bits->xhot;
  1691. X    cd.y_hot =  pCurs->bits->yhot;
  1692. X    cd.cursor = (unsigned int *) pCurs->bits->source;
  1693. X    cd.mask =   (unsigned int *) pCurs->bits->mask;
  1694. X    if ( ioctl( wsFd, LOAD_CURSOR, &cd) == -1)    {
  1695. X    ErrorF( "error loading bits of new cursor\n");
  1696. X        return FALSE;
  1697. X    }
  1698. X    cc.screen = screenDesc[pScr->myNum].screen;
  1699. X    cc.background.red = pCurs->backRed;
  1700. X    cc.background.green = pCurs->backGreen;
  1701. X    cc.background.blue = pCurs->backBlue;
  1702. X    cc.foreground.red = pCurs->foreRed;
  1703. X    cc.foreground.green  = pCurs->foreGreen;
  1704. X    cc.foreground.blue = pCurs->foreBlue;
  1705. X    if ( ioctl(wsFd, RECOLOR_CURSOR, &cc) == -1) {
  1706. X    ErrorF( "error writing colors of new cursor\n");
  1707. X        return FALSE;
  1708. X    }
  1709. X    currentCursor = pCurs;
  1710. X    return (TRUE);
  1711. X}
  1712. X
  1713. void 
  1714. wsCursorControl(screen, control)
  1715. X    int screen;
  1716. X    int control;
  1717. X{
  1718. X    ws_cursor_control cc;
  1719. X    cc.screen = screenDesc[screen].screen;
  1720. X    cc.control = control;
  1721. X    if (ioctl(wsFd, CURSOR_ON_OFF, &cc) == -1) {
  1722. X    ErrorF( "error enabling/disabling cursor\n");
  1723. X    }
  1724. X    return;
  1725. X}
  1726. static void
  1727. wsRecolorCursor (pScr, pCurs, displayed)
  1728. X    ScreenPtr    pScr;
  1729. X    CursorPtr    pCurs;
  1730. X    Bool    displayed;
  1731. X{
  1732. X    ws_cursor_color cc;
  1733. X    if (!displayed)
  1734. X    return;
  1735. X    cc.screen = screenDesc[pScr->myNum].screen;
  1736. X    cc.background.red = pCurs->backRed;
  1737. X    cc.background.green = pCurs->backGreen;
  1738. X    cc.background.blue = pCurs->backBlue;
  1739. X    cc.foreground.red = pCurs->foreRed;
  1740. X    cc.foreground.green  = pCurs->foreGreen;
  1741. X    cc.foreground.blue = pCurs->foreBlue;
  1742. X    if ( ioctl(wsFd, RECOLOR_CURSOR, &cc) == -1)    {
  1743. X    ErrorF( "error writing colors of new cursor\n");
  1744. X    }
  1745. X}
  1746. X
  1747. static Bool
  1748. wsRealizeCursor( pScr, pCurs)
  1749. X    ScreenPtr    pScr;
  1750. X    CursorPtr    pCurs;    /* The new driver makes this easy */
  1751. X{
  1752. X    return TRUE;
  1753. X}
  1754. X
  1755. static Bool
  1756. wsUnrealizeCursor( pScr, pCurs)
  1757. X    ScreenPtr    pScr;
  1758. X    CursorPtr    pCurs;
  1759. X{
  1760. X    if (pCurs == currentCursor)
  1761. X    currentCursor = 0;
  1762. X    return TRUE;
  1763. X}
  1764. X
  1765. static void
  1766. wsCursorLimits( pScr, pCurs, pHotBox, pPhysBox)
  1767. X    ScreenPtr    pScr;
  1768. X    CursorPtr    pCurs;
  1769. X    BoxPtr    pHotBox;
  1770. X    BoxPtr    pPhysBox;    /* return value */
  1771. X{
  1772. X    wsScreenPrivate *wsp = (wsScreenPrivate *)
  1773. X        pScr->devPrivates[wsScreenPrivateIndex].ptr;
  1774. X    pPhysBox->x1 = max( pHotBox->x1, 0);
  1775. X    pPhysBox->y1 = max( pHotBox->y1, 0);
  1776. X    pPhysBox->x2 = min( pHotBox->x2, wsp->screenDesc->width - 1);
  1777. X    pPhysBox->y2 = min( pHotBox->y2, wsp->screenDesc->height - 1);
  1778. X}
  1779. X
  1780. void
  1781. wsPointerNonInterestBox( pScr, pBox)
  1782. X    ScreenPtr    pScr;
  1783. X    BoxPtr    pBox;
  1784. X{
  1785. X    ws_pointer_box wsbox;
  1786. X    wsbox.screen = screenDesc[pScr->myNum].screen;
  1787. X    wsbox.device_number = wsinfo.console_pointer;
  1788. X    wsbox.enable = TRUE;
  1789. X    wsbox.box.top = pBox->x1;
  1790. X    wsbox.box.bottom =  pBox->x2;
  1791. X    wsbox.box.left = pBox->y1;
  1792. X    wsbox.box.right = pBox->y2;;
  1793. X    if (ioctl(wsFd, SET_ESCAPE_BOX, wsbox) == -1)
  1794. X        ErrorF("SET_ESCAPE_BOX: failed to set non interest box.\n");
  1795. X}
  1796. X/*
  1797. X * DDX - specific abort routine.  Called by AbortServer().
  1798. X */
  1799. void
  1800. AbortDDX()
  1801. X{
  1802. X}
  1803. X
  1804. X/* Called by GiveUp(). */
  1805. void
  1806. ddxGiveUp()
  1807. X{
  1808. X}
  1809. X
  1810. int
  1811. ArgMatch(arg, template, screen)
  1812. X    char *arg;
  1813. X    char *template;
  1814. X    int *screen;
  1815. X{
  1816. X    int tlen = strlen(template);
  1817. X    char next = *(arg + tlen);
  1818. X    if(strncmp(arg, template, tlen) == 0) {
  1819. X        if(tlen == strlen(arg)) {
  1820. X        /* exact match - applies to all screens */
  1821. X        *screen = -1;
  1822. X        return TRUE;
  1823. X    }
  1824. X    if(isdigit(next)) {
  1825. X        /* parse off screen number */
  1826. X        *screen = atoi(arg + tlen);
  1827. X        if(*screen < MAXSCREENS)
  1828. X        return TRUE;
  1829. X        else
  1830. X            return FALSE;
  1831. X    }
  1832. X    else
  1833. X        /* non-digit stuff at end of arg.  not ours. */
  1834. X        return FALSE;
  1835. X    }
  1836. X    else 
  1837. X    return FALSE;
  1838. X}
  1839. X
  1840. X
  1841. int
  1842. ddxProcessArgument (argc, argv, i)
  1843. X    register int argc;
  1844. X    register char *argv[];
  1845. X    register int i;
  1846. X{
  1847. X    int            argind=i;
  1848. X    int            skip;
  1849. X    static int        Once=0;
  1850. X    void        ddxUseMsg();
  1851. X    int         screen;
  1852. X
  1853. X    skip = 0;
  1854. X    if (!Once) {
  1855. X        blackValue = NULL;
  1856. X        whiteValue = NULL;
  1857. X    Once = 1;
  1858. X    }
  1859. X    if (ArgMatch( argv[argind], "-dpix", &screen)) {
  1860. X    if (++argind < argc) {
  1861. X        if(screen == -1) {
  1862. X        for(i = 0; i < MAXSCREENS; i++) {
  1863. X            screenArgs[i].flags |= ARG_DPIX;
  1864. X            screenArgs[i].dpix = atoi(argv[argind]);
  1865. X        }
  1866. X        }
  1867. X        else {
  1868. X        screenArgs[screen].flags |= ARG_DPIX;
  1869. X        screenArgs[screen].dpix = atoi(argv[argind]);
  1870. X        }
  1871. X        skip = 2;
  1872. X    }
  1873. X    else return 0;    /* failed to parse */
  1874. X    }
  1875. X    else if (ArgMatch( argv[argind], "-dpiy", &screen)) {
  1876. X    if (++argind < argc) {
  1877. X        if(screen == -1) {
  1878. X        for(i = 0; i < MAXSCREENS; i++) {
  1879. X            screenArgs[i].flags |= ARG_DPIY;
  1880. X            screenArgs[i].dpiy = atoi(argv[argind]);
  1881. X        }
  1882. X        }
  1883. X        else {
  1884. X        screenArgs[screen].flags |= ARG_DPIY;
  1885. X        screenArgs[screen].dpiy = atoi(argv[argind]);
  1886. X        }
  1887. X        skip = 2;
  1888. X    }
  1889. X    else return 0;
  1890. X    }
  1891. X    else if (ArgMatch( argv[argind], "-dpi", &screen)) {
  1892. X    if (++argind < argc) {
  1893. X        if(screen == -1) {
  1894. X        for(i = 0; i < MAXSCREENS; i++) {
  1895. X            screenArgs[i].flags |= (ARG_DPI | ARG_DPIX | ARG_DPIY) ;
  1896. X            screenArgs[i].dpi = screenArgs[i].dpix =
  1897. X            screenArgs[i].dpiy = atoi(argv[argind]);
  1898. X        }
  1899. X        }
  1900. X        else {
  1901. X        screenArgs[screen].flags |= (ARG_DPI | ARG_DPIX | ARG_DPIY);
  1902. X        screenArgs[screen].dpi = screenArgs[screen].dpix  =
  1903. X               screenArgs[screen].dpiy = atoi(argv[argind]);
  1904. X        }
  1905. X        skip = 2;
  1906. X    }
  1907. X    else return 0;
  1908. X    }
  1909. X    else if(ArgMatch( argv[argind], "-bp", &screen)) {
  1910. X    if (++argind < argc) {
  1911. X        if(screen == -1) {
  1912. X        for(i = 0; i < MAXSCREENS; i++) {
  1913. X            screenArgs[i].flags |= ARG_BLACKVALUE;
  1914. X            screenArgs[i].blackValue = argv[argind];
  1915. X        }
  1916. X        }
  1917. X        else {
  1918. X        screenArgs[screen].flags |=  ARG_BLACKVALUE;
  1919. X        screenArgs[screen].blackValue = argv[argind];
  1920. X        }
  1921. X        skip = 2;
  1922. X    }
  1923. X    else return 0;
  1924. X    }
  1925. X    else if (ArgMatch( argv[argind], "-wp", &screen)) {
  1926. X    if (++argind < argc) {
  1927. X        if(screen == -1) {
  1928. X        for(i = 0; i < MAXSCREENS; i++) {
  1929. X            screenArgs[i].flags |= ARG_WHITEVALUE;
  1930. X            screenArgs[i].whiteValue = argv[argind];
  1931. X        }
  1932. X        }
  1933. X        else {
  1934. X        screenArgs[screen].flags |=  ARG_WHITEVALUE;
  1935. X        screenArgs[screen].whiteValue = argv[argind];
  1936. X        }
  1937. X        skip = 2;
  1938. X    }
  1939. X    else return 0;
  1940. X    }
  1941. X    else if (ArgMatch(argv[argind], "-class", &screen))  {
  1942. X    if(++argind < argc)  {
  1943. X        int class = ParseClass(argv[argind]);
  1944. X        if (class == NoSuchClass)
  1945. X        return 0;
  1946. X        if(screen == -1) {
  1947. X        for(i = 0; i < MAXSCREENS; i++) {
  1948. X            screenArgs[i].flags |= ARG_CLASS;
  1949. X            screenArgs[i].class = class;
  1950. X        }
  1951. X        }
  1952. X        else {
  1953. X        screenArgs[screen].flags |=  ARG_CLASS;
  1954. X        screenArgs[screen].class = class;
  1955. X        }
  1956. X        skip = 2;
  1957. X        }
  1958. X    else return 0;
  1959. X    }
  1960. X    else if (ArgMatch(argv[argind], "-edge_left", &screen))  {
  1961. X    if(++argind < argc)  {
  1962. X        if(screen == -1) {
  1963. X        return 0;
  1964. X        }
  1965. X        else {
  1966. X        screenArgs[screen].flags |=  ARG_EDGE_L;
  1967. X        screenArgs[screen].edge_left = atoi(argv[argind]);
  1968. X        }
  1969. X        skip = 2;
  1970. X        }
  1971. X    else return 0;
  1972. X    }
  1973. X    else if (ArgMatch(argv[argind], "-edge_right", &screen))  {
  1974. X    if(++argind < argc)  {
  1975. X        if(screen == -1) {
  1976. X        return 0;
  1977. X        }
  1978. X        else {
  1979. X        screenArgs[screen].flags |=  ARG_EDGE_R;
  1980. X        screenArgs[screen].edge_right = atoi(argv[argind]);
  1981. X        }
  1982. X        skip = 2;
  1983. X        }
  1984. X    else return 0;
  1985. X    }
  1986. X    else if (ArgMatch(argv[argind], "-edge_top", &screen))  {
  1987. X    if(++argind < argc)  {
  1988. X        if(screen == -1) {
  1989. X        return 0;
  1990. X        }
  1991. X        else {
  1992. X        screenArgs[screen].flags |=  ARG_EDGE_T;
  1993. X        screenArgs[screen].edge_top = atoi(argv[argind]);
  1994. X        }
  1995. X        skip = 2;
  1996. X        }
  1997. X    else return 0;
  1998. X    }
  1999. X    else if (ArgMatch(argv[argind], "-edge_bottom", &screen))  {
  2000. X    if(++argind < argc)  {
  2001. X        if(screen == -1) {
  2002. X        return 0;
  2003. X        }
  2004. X        else {
  2005. X        screenArgs[screen].flags |=  ARG_EDGE_B;
  2006. X        screenArgs[screen].edge_bottom = atoi(argv[argind]);
  2007. X        }
  2008. X        skip = 2;
  2009. X        }
  2010. X    else return 0;
  2011. X    }
  2012. X
  2013. X    else if (ArgMatch(argv[argind], "-monitor", &screen))  {
  2014. X    if(++argind + 4 < argc)  {
  2015. X        if(strlen(argv[argind]) == 5) {
  2016. X        strcpy(screenArgs[screen].monitor.type, argv[argind++]);
  2017. X        screenArgs[screen].monitor.mm_width =  atoi(argv[argind++]);
  2018. X        screenArgs[screen].monitor.mm_height =  atoi(argv[argind++]);
  2019. X        screenArgs[screen].monitor.color_or_mono =atoi(argv[argind++]);
  2020. X        screenArgs[screen].monitor.phosphor_type =atoi(argv[argind++]);
  2021. X        screenArgs[screen].flags |=  ARG_MONITOR;
  2022. X            skip = 6;
  2023. X        }
  2024. X        else return 0;
  2025. X        }
  2026. X    else return 0;
  2027. X    }
  2028. X    else if (strcmp( argv[argind], "-btn") == 0)
  2029. X    {
  2030. X    if (++argind < argc)
  2031. X    {
  2032. X        wsNumButtons = atoi(argv[argind]);
  2033. X        skip = 2;
  2034. X        if(wsNumButtons < 1 || wsNumButtons > 5)
  2035. X        return 0;
  2036. X    }
  2037. X    else return 0;
  2038. X    }
  2039. X
  2040. X#ifdef XINPUT
  2041. X    else
  2042. X    skip = ExtddxProcessArgument(argc, argv, argind);
  2043. X#endif
  2044. X
  2045. X    return skip;
  2046. X}
  2047. X
  2048. initEdgeAttachments(index)
  2049. X    int index;
  2050. X{
  2051. X    ws_edge_connection wec;
  2052. X    ScreenArgsRec *args = &screenArgs[index];
  2053. X    int mask = args->flags;
  2054. X    wec.screen = index;
  2055. X    if(mask & ARG_EDGE_L)
  2056. X    wec.adj_screens.left = args->edge_left;
  2057. X    else
  2058. X    wec.adj_screens.left = index - 1;
  2059. X    if(mask & ARG_EDGE_R)
  2060. X    wec.adj_screens.right =     args->edge_right;
  2061. X    else
  2062. X    if(index + 1 < wsinfo.num_screens_exist)
  2063. X        wec.adj_screens.right = index + 1;    
  2064. X    else
  2065. X         wec.adj_screens.right = -1;        
  2066. X    if(mask & ARG_EDGE_T)
  2067. X    wec.adj_screens.top = args->edge_top;
  2068. X    else
  2069. X    wec.adj_screens.top = -1;
  2070. X    if(mask & ARG_EDGE_B)
  2071. X    wec.adj_screens.bottom = args->edge_bottom;
  2072. X    else
  2073. X    wec.adj_screens.bottom = -1;
  2074. X    if (ioctl(wsFd, SET_EDGE_CONNECTION, &wec) == -1)
  2075. X      ErrorF("SET_EDGE_CONNECTION, failed to set edge attachment.\n");
  2076. X    
  2077. X}
  2078. X
  2079. X#define ARGFILE "/etc/screens"
  2080. X
  2081. void getFileArguments()
  2082. X{
  2083. X    FILE *f =  fopen(ARGFILE, "r");
  2084. X    if(f) {
  2085. X        struct stat stats;
  2086. X    if(stat(ARGFILE, &stats) == 0) {
  2087. X        int i, argcount = 0, skip;
  2088. X        char *ptr, *buf = (char *)Xalloc(stats.st_size);
  2089. X        char **arguments;
  2090. X        while(EOF != fscanf(f, "%s", buf)) argcount++;
  2091. X        arguments =  (char **) Xalloc(argcount * sizeof(char *));
  2092. X            rewind(f);
  2093. X        for(ptr = buf, i = 0; i < argcount; i++) {
  2094. X            arguments[i] = ptr;
  2095. X        fscanf(f, "%s", ptr);
  2096. X        ptr += strlen(arguments[i]) + 1;
  2097. X        }
  2098. X        fclose(f);
  2099. X        for(i = 0; i < argcount; i++) 
  2100. X        if(skip = ddxProcessArgument(argcount, arguments, i))
  2101. X            i +=  (skip - 1);
  2102. X        Xfree(arguments);
  2103. X        Xfree(buf);
  2104. X    }    
  2105. X    }
  2106. X}
  2107. X
  2108. X
  2109. void
  2110. ddxUseMsg()
  2111. X{
  2112. X    ErrorF ("\n");
  2113. X    ErrorF ("\n");
  2114. X    ErrorF ("Device Dependent Usage\n");
  2115. X    ErrorF ("Note - most ddx arguments can take an optional screen number ``s''\n");
  2116. X    ErrorF ("\n");
  2117. X    ErrorF ("-btn <n>              Number of buttons on pointer device\n");
  2118. X    ErrorF ("-dpix[s] <n>          Dots per inch, x coordinate\n");
  2119. X    ErrorF ("-dpiy[s] <n>          Dots per inch, y coordinate\n");
  2120. X    ErrorF ("-dpi[s] <n>           Dots per inch, x and y coordinates\n");
  2121. X    ErrorF ("                   (overrides -dpix and -dpiy above)\n");
  2122. X    ErrorF ("-bp[s] #XXX           color for BlackPixel for screen\n");
  2123. X    ErrorF ("-wp[s] #XXX           color for WhitePixel for screen\n");
  2124. X    ErrorF ("-class[s] <classname> type of Visual for root window\n");
  2125. X    ErrorF ("       one of StaticGray, StaticColor, PseudoColor,\n");
  2126. X    ErrorF ("       GrayScale, or even TrueColor!\n");
  2127. X    ErrorF ("-edge_left<s1> <s2> Attach left edge of screen s1 to screen s2\n");
  2128. X    ErrorF ("-edge_right<s1> <s2> Attach right edge of screen s1 to screen s2\n");
  2129. X    ErrorF ("-edge_top<s1> <s2> Attach top edge of screen s1 to screen s2\n");
  2130. X    ErrorF ("-edge_bottom<s1> <s2> Attach bottom edge of screen s1 to screen s2\n");
  2131. X
  2132. X#ifdef XINPUT
  2133. X    ExtddxUseMsg();
  2134. X#endif
  2135. X}
  2136. X
  2137. X/* ARGSUSED */
  2138. int wsScreenInit(index, pScreen, argc, argv)
  2139. X    int index;
  2140. X    register ScreenPtr pScreen;
  2141. X    int argc;
  2142. X    char **argv;
  2143. X{
  2144. X
  2145. X    pScreen->SaveScreen = wsSaveScreen;
  2146. X    pScreen->RealizeCursor = wsRealizeCursor;
  2147. X    pScreen->UnrealizeCursor = wsUnrealizeCursor;
  2148. X    pScreen->DisplayCursor = wsDisplayCursor;
  2149. X    pScreen->SetCursorPosition = wsSetCursorPosition;
  2150. X    pScreen->CursorLimits = wsCursorLimits;
  2151. X    pScreen->PointerNonInterestBox = wsPointerNonInterestBox;
  2152. X    pScreen->ConstrainCursor = wsConstrainCursor;
  2153. X    pScreen->RecolorCursor = wsRecolorCursor;
  2154. X    pScreen->StoreColors = wsStoreColors;
  2155. X    pScreen->InstallColormap = wsInstallColormap;
  2156. X    pScreen->UninstallColormap = wsUninstallColormap;
  2157. X    pScreen->ListInstalledColormaps = wsListInstalledColormaps;
  2158. X
  2159. X    initEdgeAttachments(index);
  2160. X    if(screenArgs[index].flags & ARG_MONITOR) {
  2161. X    ws_monitor_type wmt;
  2162. X    wmt.screen = index;
  2163. X    wmt.monitor_type = screenArgs[index].monitor;
  2164. X    if (ioctl(wsFd, SET_MONITOR_TYPE, &wmt) == -1)
  2165. X        ErrorF("SET_MONITOR_TYPE, failed to set monitor type.\n");
  2166. X    }
  2167. X    wsSaveScreen(pScreen,  SCREEN_SAVER_OFF);
  2168. X    return index;
  2169. X}
  2170. END_OF_FILE
  2171. if test 34338 -ne `wc -c <'server/ddx/dec/ws/ws_io.c'`; then
  2172.     echo shar: \"'server/ddx/dec/ws/ws_io.c'\" unpacked with wrong size!
  2173. fi
  2174. # end of 'server/ddx/dec/ws/ws_io.c'
  2175. fi
  2176. echo shar: End of archive 2 \(of 2\).
  2177. cp /dev/null ark2isdone
  2178. MISSING=""
  2179. for I in 1 2 ; do
  2180.     if test ! -f ark${I}isdone ; then
  2181.     MISSING="${MISSING} ${I}"
  2182.     fi
  2183. done
  2184. if test "${MISSING}" = "" ; then
  2185.     echo You have unpacked both archives.
  2186.     rm -f ark[1-9]isdone
  2187. else
  2188.     echo You still need to unpack the following archives:
  2189.     echo "        " ${MISSING}
  2190. fi
  2191. ##  End of shell archive.
  2192. exit 0
  2193.  
  2194. --
  2195. Dan Heller
  2196. O'Reilly && Associates       Z-Code Software    Comp-sources-x:
  2197. Senior Writer                President          comp-sources-x@uunet.uu.net
  2198. argv@ora.com                 argv@zipcode.com
  2199.